diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 4.0.21 + ++ Update to haskell-gi(-base) 0.22 + +### 4.0.20 + ++ Update stack version to 12.10 + ### 4.0.19 + Add multiple missing nullable annotations. diff --git a/GI/WebKit2.hs b/GI/WebKit2.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2.hs @@ -0,0 +1,60 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2 + ( module GI.WebKit2.Callbacks , + module GI.WebKit2.Constants , + module GI.WebKit2.Enums , + module GI.WebKit2.Flags , + module GI.WebKit2.Functions , + module GI.WebKit2.Interfaces , + module GI.WebKit2.Objects , + module GI.WebKit2.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.WebKit2.Callbacks +import GI.WebKit2.Constants +import GI.WebKit2.Enums +import GI.WebKit2.Flags +import GI.WebKit2.Functions +import GI.WebKit2.Interfaces +import GI.WebKit2.Objects +import GI.WebKit2.Structs + +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 Data.GI.Base + diff --git a/GI/WebKit2/Callbacks.hs b/GI/WebKit2/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Callbacks.hs @@ -0,0 +1,142 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Callbacks + ( + + -- * Signals +-- ** URISchemeRequestCallback #signal:URISchemeRequestCallback# + + C_URISchemeRequestCallback , + URISchemeRequestCallback , + URISchemeRequestCallback_WithClosures , + drop_closures_URISchemeRequestCallback , + dynamic_URISchemeRequestCallback , + genClosure_URISchemeRequestCallback , + mk_URISchemeRequestCallback , + noURISchemeRequestCallback , + noURISchemeRequestCallback_WithClosures , + wrap_URISchemeRequestCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.URISchemeRequest as WebKit2.URISchemeRequest + +-- callback URISchemeRequestCallback +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitURISchemeRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Type definition for a function that will be called back when an URI request is\nmade for a user registered URI scheme.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_URISchemeRequestCallback = + Ptr WebKit2.URISchemeRequest.URISchemeRequest -> + Ptr () -> + IO () + +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitURISchemeRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_URISchemeRequestCallback :: FunPtr C_URISchemeRequestCallback -> C_URISchemeRequestCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_URISchemeRequestCallback :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.URISchemeRequest.IsURISchemeRequest a) => + FunPtr C_URISchemeRequestCallback + -> a + {- ^ /@request@/: the 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> Ptr () + {- ^ /@userData@/: user data passed to the callback -} + -> m () +dynamic_URISchemeRequestCallback __funPtr request userData = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + (__dynamic_C_URISchemeRequestCallback __funPtr) request' userData + touchManagedPtr request + return () + +-- | Generate a function pointer callable from C code, from a `C_URISchemeRequestCallback`. +foreign import ccall "wrapper" + mk_URISchemeRequestCallback :: C_URISchemeRequestCallback -> IO (FunPtr C_URISchemeRequestCallback) + +{- | +Type definition for a function that will be called back when an URI request is +made for a user registered URI scheme. +-} +type URISchemeRequestCallback = + WebKit2.URISchemeRequest.URISchemeRequest + {- ^ /@request@/: the 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `URISchemeRequestCallback`@. +noURISchemeRequestCallback :: Maybe URISchemeRequestCallback +noURISchemeRequestCallback = Nothing + +{- | +Type definition for a function that will be called back when an URI request is +made for a user registered URI scheme. +-} +type URISchemeRequestCallback_WithClosures = + WebKit2.URISchemeRequest.URISchemeRequest + {- ^ /@request@/: the 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> Ptr () + {- ^ /@userData@/: user data passed to the callback -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `URISchemeRequestCallback_WithClosures`@. +noURISchemeRequestCallback_WithClosures :: Maybe URISchemeRequestCallback_WithClosures +noURISchemeRequestCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_URISchemeRequestCallback :: URISchemeRequestCallback -> URISchemeRequestCallback_WithClosures +drop_closures_URISchemeRequestCallback _f request _ = _f request + +-- | Wrap the callback into a `GClosure`. +genClosure_URISchemeRequestCallback :: MonadIO m => URISchemeRequestCallback -> m (GClosure C_URISchemeRequestCallback) +genClosure_URISchemeRequestCallback cb = liftIO $ do + let cb' = drop_closures_URISchemeRequestCallback cb + let cb'' = wrap_URISchemeRequestCallback Nothing cb' + mk_URISchemeRequestCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `URISchemeRequestCallback` into a `C_URISchemeRequestCallback`. +wrap_URISchemeRequestCallback :: + Maybe (Ptr (FunPtr C_URISchemeRequestCallback)) -> + URISchemeRequestCallback_WithClosures -> + C_URISchemeRequestCallback +wrap_URISchemeRequestCallback funptrptr _cb request userData = do + request' <- (newObject WebKit2.URISchemeRequest.URISchemeRequest) request + _cb request' userData + maybeReleaseFunPtr funptrptr + + + diff --git a/GI/WebKit2/Constants.hs b/GI/WebKit2/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Constants.hs @@ -0,0 +1,148 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Constants + ( + pattern MINOR_VERSION , + pattern MICRO_VERSION , + pattern MAJOR_VERSION , + pattern EDITING_COMMAND_UNDO , + pattern EDITING_COMMAND_SELECT_ALL , + pattern EDITING_COMMAND_REDO , + pattern EDITING_COMMAND_PASTE , + pattern EDITING_COMMAND_INSERT_IMAGE , + pattern EDITING_COMMAND_CUT , + pattern EDITING_COMMAND_CREATE_LINK , + pattern EDITING_COMMAND_COPY , + + ) 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 + + +{- | +Like 'GI.WebKit2.Functions.getMinorVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MINOR_VERSION = 24 :: Int32 + +{- | +Like 'GI.WebKit2.Functions.getMicroVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MICRO_VERSION = 2 :: Int32 + +{- | +Like 'GI.WebKit2.Functions.getMajorVersion', but from the headers used at +application compile time, rather than from the library linked +against at application run time. +-} +pattern MAJOR_VERSION = 2 :: Int32 + +{- | +The undo command. Undoes the last editing command in a 'GI.WebKit2.Objects.WebView.WebView'. +You can check whether it\'s possible to execute the command with +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. It\'s only possible +to undo a command after a previously executed editing operation. +-} +pattern EDITING_COMMAND_UNDO = "Undo" :: T.Text + +{- | +The select all command. Selects all the content of the current text field in +a 'GI.WebKit2.Objects.WebView.WebView'. +It is always possible to select all text, no matter whether the +'GI.WebKit2.Objects.WebView.WebView' content is editable or not. You can still check it +with 'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. +-} +pattern EDITING_COMMAND_SELECT_ALL = "SelectAll" :: T.Text + +{- | +The redo command. Redoes a previously undone editing command in +a 'GI.WebKit2.Objects.WebView.WebView'. +You can check whether it\'s possible to execute the command with +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. It\'s only possible +to redo a command when it has been previously undone. +-} +pattern EDITING_COMMAND_REDO = "Redo" :: T.Text + +{- | +The paste clipboard command. Pastes the contents of the clipboard to +a 'GI.WebKit2.Objects.WebView.WebView'. +You can check whether it\'s possible to execute the command with +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. In general it\'s possible +to paste from the clipboard when the 'GI.WebKit2.Objects.WebView.WebView' content is editable +and clipboard is not empty. +-} +pattern EDITING_COMMAND_PASTE = "Paste" :: T.Text + +{- | +The insert image command. Creates an image element that is inserted at +the current cursor position. It receives an URI as argument, +that is used as the image source. This command should be executed with +'GI.WebKit2.Objects.WebView.webViewExecuteEditingCommandWithArgument'. + +/Since: 2.10/ +-} +pattern EDITING_COMMAND_INSERT_IMAGE = "InsertImage" :: T.Text + +{- | +The cut clipboard command. Copies the current selection inside +a 'GI.WebKit2.Objects.WebView.WebView' to the clipboard and deletes the selected content. +You can check whether it\'s possible to execute the command with +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. In general it\'s +possible to cut to the clipboard when the 'GI.WebKit2.Objects.WebView.WebView' content is +editable and there is an active selection. +-} +pattern EDITING_COMMAND_CUT = "Cut" :: T.Text + +{- | +The create link command. Creates a link element that is inserted at +the current cursor position. If there\'s a selection, the selected text +will be used as the link text, otherwise the URL itself will be used. +It receives the link URL as argument. This command should be executed +with 'GI.WebKit2.Objects.WebView.webViewExecuteEditingCommandWithArgument' + +/Since: 2.10/ +-} +pattern EDITING_COMMAND_CREATE_LINK = "CreateLink" :: T.Text + +{- | +The copy clipboard command. Copies the current selection inside +a 'GI.WebKit2.Objects.WebView.WebView' to the clipboard. +You can check whether it\'s possible to execute the command with +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. In general it\'s +possible to copy to the clipboard when there is an active selection +inside the 'GI.WebKit2.Objects.WebView.WebView'. +-} +pattern EDITING_COMMAND_COPY = "Copy" :: T.Text + + diff --git a/GI/WebKit2/Enums.hs b/GI/WebKit2/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Enums.hs @@ -0,0 +1,1991 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Enums + ( + + -- * Enumerations +-- ** AuthenticationScheme #enum:AuthenticationScheme# + + AuthenticationScheme(..) , + + +-- ** CacheModel #enum:CacheModel# + + CacheModel(..) , + + +-- ** ContextMenuAction #enum:ContextMenuAction# + + ContextMenuAction(..) , + + +-- ** CookieAcceptPolicy #enum:CookieAcceptPolicy# + + CookieAcceptPolicy(..) , + + +-- ** CookiePersistentStorage #enum:CookiePersistentStorage# + + CookiePersistentStorage(..) , + + +-- ** CredentialPersistence #enum:CredentialPersistence# + + CredentialPersistence(..) , + + +-- ** DownloadError #enum:DownloadError# + + DownloadError(..) , + catchDownloadError , + handleDownloadError , + + +-- ** FaviconDatabaseError #enum:FaviconDatabaseError# + + FaviconDatabaseError(..) , + catchFaviconDatabaseError , + handleFaviconDatabaseError , + + +-- ** HardwareAccelerationPolicy #enum:HardwareAccelerationPolicy# + + HardwareAccelerationPolicy(..) , + + +-- ** InsecureContentEvent #enum:InsecureContentEvent# + + InsecureContentEvent(..) , + + +-- ** JavascriptError #enum:JavascriptError# + + JavascriptError(..) , + catchJavascriptError , + handleJavascriptError , + + +-- ** LoadEvent #enum:LoadEvent# + + LoadEvent(..) , + + +-- ** NavigationType #enum:NavigationType# + + NavigationType(..) , + + +-- ** NetworkError #enum:NetworkError# + + NetworkError(..) , + catchNetworkError , + handleNetworkError , + + +-- ** NetworkProxyMode #enum:NetworkProxyMode# + + NetworkProxyMode(..) , + + +-- ** PluginError #enum:PluginError# + + PluginError(..) , + catchPluginError , + handlePluginError , + + +-- ** PolicyDecisionType #enum:PolicyDecisionType# + + PolicyDecisionType(..) , + + +-- ** PolicyError #enum:PolicyError# + + PolicyError(..) , + catchPolicyError , + handlePolicyError , + + +-- ** PrintError #enum:PrintError# + + PrintError(..) , + catchPrintError , + handlePrintError , + + +-- ** PrintOperationResponse #enum:PrintOperationResponse# + + PrintOperationResponse(..) , + + +-- ** ProcessModel #enum:ProcessModel# + + ProcessModel(..) , + + +-- ** SaveMode #enum:SaveMode# + + SaveMode(..) , + + +-- ** ScriptDialogType #enum:ScriptDialogType# + + ScriptDialogType(..) , + + +-- ** SnapshotError #enum:SnapshotError# + + SnapshotError(..) , + catchSnapshotError , + handleSnapshotError , + + +-- ** SnapshotRegion #enum:SnapshotRegion# + + SnapshotRegion(..) , + + +-- ** TLSErrorsPolicy #enum:TLSErrorsPolicy# + + TLSErrorsPolicy(..) , + + +-- ** UserContentFilterError #enum:UserContentFilterError# + + UserContentFilterError(..) , + catchUserContentFilterError , + handleUserContentFilterError , + + +-- ** UserContentInjectedFrames #enum:UserContentInjectedFrames# + + UserContentInjectedFrames(..) , + + +-- ** UserScriptInjectionTime #enum:UserScriptInjectionTime# + + UserScriptInjectionTime(..) , + + +-- ** UserStyleLevel #enum:UserStyleLevel# + + UserStyleLevel(..) , + + +-- ** WebProcessTerminationReason #enum:WebProcessTerminationReason# + + WebProcessTerminationReason(..) , + + + + + ) 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 + + +-- Enum WebProcessTerminationReason +{- | +Enum values used to specify the reason why the web process terminated abnormally. + +/Since: 2.20/ +-} +data WebProcessTerminationReason = + WebProcessTerminationReasonCrashed + {- ^ + the web process crashed. + -} + | WebProcessTerminationReasonExceededMemoryLimit + {- ^ + the web process exceeded the memory limit. + -} + | AnotherWebProcessTerminationReason Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum WebProcessTerminationReason where + fromEnum WebProcessTerminationReasonCrashed = 0 + fromEnum WebProcessTerminationReasonExceededMemoryLimit = 1 + fromEnum (AnotherWebProcessTerminationReason k) = k + + toEnum 0 = WebProcessTerminationReasonCrashed + toEnum 1 = WebProcessTerminationReasonExceededMemoryLimit + toEnum k = AnotherWebProcessTerminationReason k + +instance P.Ord WebProcessTerminationReason where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_web_process_termination_reason_get_type" c_webkit_web_process_termination_reason_get_type :: + IO GType + +instance BoxedEnum WebProcessTerminationReason where + boxedEnumType _ = c_webkit_web_process_termination_reason_get_type + +-- Enum UserStyleLevel +{- | +Specifies how to treat an user style sheet. + +/Since: 2.6/ +-} +data UserStyleLevel = + UserStyleLevelUser + {- ^ + The style sheet is an user style sheet, + its contents always override other style sheets. This is the default. + -} + | UserStyleLevelAuthor + {- ^ + The style sheet will be treated as if + it was provided by the loaded documents. That means other user style + sheets may still override it. + -} + | AnotherUserStyleLevel Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum UserStyleLevel where + fromEnum UserStyleLevelUser = 0 + fromEnum UserStyleLevelAuthor = 1 + fromEnum (AnotherUserStyleLevel k) = k + + toEnum 0 = UserStyleLevelUser + toEnum 1 = UserStyleLevelAuthor + toEnum k = AnotherUserStyleLevel k + +instance P.Ord UserStyleLevel where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_user_style_level_get_type" c_webkit_user_style_level_get_type :: + IO GType + +instance BoxedEnum UserStyleLevel where + boxedEnumType _ = c_webkit_user_style_level_get_type + +-- Enum UserScriptInjectionTime +{- | +Specifies at which place of documents an user script will be inserted. + +/Since: 2.6/ +-} +data UserScriptInjectionTime = + UserScriptInjectionTimeStart + {- ^ + Insert the code of the user + script at the beginning of loaded documents. This is the default. + -} + | UserScriptInjectionTimeEnd + {- ^ + Insert the code of the user + script at the end of the loaded documents. + -} + | AnotherUserScriptInjectionTime Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum UserScriptInjectionTime where + fromEnum UserScriptInjectionTimeStart = 0 + fromEnum UserScriptInjectionTimeEnd = 1 + fromEnum (AnotherUserScriptInjectionTime k) = k + + toEnum 0 = UserScriptInjectionTimeStart + toEnum 1 = UserScriptInjectionTimeEnd + toEnum k = AnotherUserScriptInjectionTime k + +instance P.Ord UserScriptInjectionTime where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_user_script_injection_time_get_type" c_webkit_user_script_injection_time_get_type :: + IO GType + +instance BoxedEnum UserScriptInjectionTime where + boxedEnumType _ = c_webkit_user_script_injection_time_get_type + +-- Enum UserContentInjectedFrames +{- | +Specifies in which frames user style sheets are to be inserted in. + +/Since: 2.6/ +-} +data UserContentInjectedFrames = + UserContentInjectedFramesAllFrames + {- ^ + Insert the user style + sheet in all the frames loaded by the web view, including + nested frames. This is the default. + -} + | UserContentInjectedFramesTopFrame + {- ^ + Insert the user style + sheet *only* in the top-level frame loaded by the web view, + and *not* in the nested frames. + -} + | AnotherUserContentInjectedFrames Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum UserContentInjectedFrames where + fromEnum UserContentInjectedFramesAllFrames = 0 + fromEnum UserContentInjectedFramesTopFrame = 1 + fromEnum (AnotherUserContentInjectedFrames k) = k + + toEnum 0 = UserContentInjectedFramesAllFrames + toEnum 1 = UserContentInjectedFramesTopFrame + toEnum k = AnotherUserContentInjectedFrames k + +instance P.Ord UserContentInjectedFrames where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_user_content_injected_frames_get_type" c_webkit_user_content_injected_frames_get_type :: + IO GType + +instance BoxedEnum UserContentInjectedFrames where + boxedEnumType _ = c_webkit_user_content_injected_frames_get_type + +-- Enum UserContentFilterError +{- | +/No description available in the introspection data./ + +/Since: 2.24/ +-} +data UserContentFilterError = + UserContentFilterErrorInvalidSource + {- ^ + The JSON source for a content filter is invalid. + -} + | UserContentFilterErrorNotFound + {- ^ + The requested content filter could not be found. + -} + | AnotherUserContentFilterError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum UserContentFilterError where + fromEnum UserContentFilterErrorInvalidSource = 0 + fromEnum UserContentFilterErrorNotFound = 1 + fromEnum (AnotherUserContentFilterError k) = k + + toEnum 0 = UserContentFilterErrorInvalidSource + toEnum 1 = UserContentFilterErrorNotFound + toEnum k = AnotherUserContentFilterError k + +instance P.Ord UserContentFilterError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass UserContentFilterError where + gerrorClassDomain _ = "WebKitUserContentFilterError" + +-- | Catch exceptions of type `UserContentFilterError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchUserContentFilterError :: + IO a -> + (UserContentFilterError -> GErrorMessage -> IO a) -> + IO a +catchUserContentFilterError = catchGErrorJustDomain + +-- | Handle exceptions of type `UserContentFilterError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleUserContentFilterError :: + (UserContentFilterError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleUserContentFilterError = handleGErrorJustDomain + +foreign import ccall "webkit_user_content_filter_error_get_type" c_webkit_user_content_filter_error_get_type :: + IO GType + +instance BoxedEnum UserContentFilterError where + boxedEnumType _ = c_webkit_user_content_filter_error_get_type + +-- Enum TLSErrorsPolicy +{- | +Enum values used to denote the TLS errors policy. +-} +data TLSErrorsPolicy = + TLSErrorsPolicyIgnore + {- ^ + Ignore TLS errors. + -} + | TLSErrorsPolicyFail + {- ^ + TLS errors will emit + 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed-with-tls-errors/@ and, if the signal is handled, + finish the load. In case the signal is not handled, + 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ is emitted before the load finishes. + -} + | AnotherTLSErrorsPolicy Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum TLSErrorsPolicy where + fromEnum TLSErrorsPolicyIgnore = 0 + fromEnum TLSErrorsPolicyFail = 1 + fromEnum (AnotherTLSErrorsPolicy k) = k + + toEnum 0 = TLSErrorsPolicyIgnore + toEnum 1 = TLSErrorsPolicyFail + toEnum k = AnotherTLSErrorsPolicy k + +instance P.Ord TLSErrorsPolicy where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_tls_errors_policy_get_type" c_webkit_tls_errors_policy_get_type :: + IO GType + +instance BoxedEnum TLSErrorsPolicy where + boxedEnumType _ = c_webkit_tls_errors_policy_get_type + +-- Enum SnapshotRegion +{- | +Enum values used to specify the region from which to get a 'GI.WebKit2.Objects.WebView.WebView' +snapshot +-} +data SnapshotRegion = + SnapshotRegionVisible + {- ^ + Specifies a snapshot only for the area that is + visible in the webview + -} + | SnapshotRegionFullDocument + {- ^ + A snapshot of the entire document. + -} + | AnotherSnapshotRegion Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SnapshotRegion where + fromEnum SnapshotRegionVisible = 0 + fromEnum SnapshotRegionFullDocument = 1 + fromEnum (AnotherSnapshotRegion k) = k + + toEnum 0 = SnapshotRegionVisible + toEnum 1 = SnapshotRegionFullDocument + toEnum k = AnotherSnapshotRegion k + +instance P.Ord SnapshotRegion where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_snapshot_region_get_type" c_webkit_snapshot_region_get_type :: + IO GType + +instance BoxedEnum SnapshotRegion where + boxedEnumType _ = c_webkit_snapshot_region_get_type + +-- Enum SnapshotError +{- | +Enum values used to denote errors happening when creating snapshots of 'GI.WebKit2.Objects.WebView.WebView' +-} +data SnapshotError = + SnapshotErrorCreate + {- ^ + An error occurred when creating a webpage snapshot. + -} + | AnotherSnapshotError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SnapshotError where + fromEnum SnapshotErrorCreate = 799 + fromEnum (AnotherSnapshotError k) = k + + toEnum 799 = SnapshotErrorCreate + toEnum k = AnotherSnapshotError k + +instance P.Ord SnapshotError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass SnapshotError where + gerrorClassDomain _ = "WebKitSnapshotError" + +-- | Catch exceptions of type `SnapshotError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchSnapshotError :: + IO a -> + (SnapshotError -> GErrorMessage -> IO a) -> + IO a +catchSnapshotError = catchGErrorJustDomain + +-- | Handle exceptions of type `SnapshotError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleSnapshotError :: + (SnapshotError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleSnapshotError = handleGErrorJustDomain + +foreign import ccall "webkit_snapshot_error_get_type" c_webkit_snapshot_error_get_type :: + IO GType + +instance BoxedEnum SnapshotError where + boxedEnumType _ = c_webkit_snapshot_error_get_type + +-- Enum ScriptDialogType +{- | +Enum values used for determining the type of 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' +-} +data ScriptDialogType = + ScriptDialogTypeAlert + {- ^ + Alert script dialog, used to show a + message to the user. + -} + | ScriptDialogTypeConfirm + {- ^ + Confirm script dialog, used to ask + confirmation to the user. + -} + | ScriptDialogTypePrompt + {- ^ + Prompt script dialog, used to ask + information to the user. + -} + | ScriptDialogTypeBeforeUnloadConfirm + {- ^ + Before unload confirm dialog, + used to ask confirmation to leave the current page to the user. Since 2.12 + -} + | AnotherScriptDialogType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ScriptDialogType where + fromEnum ScriptDialogTypeAlert = 0 + fromEnum ScriptDialogTypeConfirm = 1 + fromEnum ScriptDialogTypePrompt = 2 + fromEnum ScriptDialogTypeBeforeUnloadConfirm = 3 + fromEnum (AnotherScriptDialogType k) = k + + toEnum 0 = ScriptDialogTypeAlert + toEnum 1 = ScriptDialogTypeConfirm + toEnum 2 = ScriptDialogTypePrompt + toEnum 3 = ScriptDialogTypeBeforeUnloadConfirm + toEnum k = AnotherScriptDialogType k + +instance P.Ord ScriptDialogType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_script_dialog_type_get_type" c_webkit_script_dialog_type_get_type :: + IO GType + +instance BoxedEnum ScriptDialogType where + boxedEnumType _ = c_webkit_script_dialog_type_get_type + +-- Enum SaveMode +{- | +Enum values to specify the different ways in which a 'GI.WebKit2.Objects.WebView.WebView' +can save its current web page into a self-contained file. +-} +data SaveMode = + SaveModeMhtml + {- ^ + Save the current page using the MHTML format. + -} + | AnotherSaveMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SaveMode where + fromEnum SaveModeMhtml = 0 + fromEnum (AnotherSaveMode k) = k + + toEnum 0 = SaveModeMhtml + toEnum k = AnotherSaveMode k + +instance P.Ord SaveMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_save_mode_get_type" c_webkit_save_mode_get_type :: + IO GType + +instance BoxedEnum SaveMode where + boxedEnumType _ = c_webkit_save_mode_get_type + +-- Enum ProcessModel +{- | +Enum values used for determining the 'GI.WebKit2.Objects.WebContext.WebContext' process model. + +/Since: 2.4/ +-} +data ProcessModel = + ProcessModelSharedSecondaryProcess + {- ^ + Use a single process to + perform content rendering. The process is shared among all the + 'GI.WebKit2.Objects.WebView.WebView' instances created by the application: if the process + hangs or crashes all the web views in the application will be affected. + This is the default process model, and it should suffice for most cases. + -} + | ProcessModelMultipleSecondaryProcesses + {- ^ + Use one process + for each 'GI.WebKit2.Objects.WebView.WebView', while still allowing for some of them to + share a process in certain situations. The main advantage + of this process model is that the rendering process for a web view + can crash while the rest of the views keep working normally. This + process model is indicated for applications which may use a number + of web views and the content of in each must not interfere with the + rest — for example a full-fledged web browser with support for + multiple tabs. + -} + | AnotherProcessModel Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ProcessModel where + fromEnum ProcessModelSharedSecondaryProcess = 0 + fromEnum ProcessModelMultipleSecondaryProcesses = 1 + fromEnum (AnotherProcessModel k) = k + + toEnum 0 = ProcessModelSharedSecondaryProcess + toEnum 1 = ProcessModelMultipleSecondaryProcesses + toEnum k = AnotherProcessModel k + +instance P.Ord ProcessModel where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_process_model_get_type" c_webkit_process_model_get_type :: + IO GType + +instance BoxedEnum ProcessModel where + boxedEnumType _ = c_webkit_process_model_get_type + +-- Enum PrintOperationResponse +{- | +Enum values representing the response of the print dialog shown with +'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog'. +-} +data PrintOperationResponse = + PrintOperationResponsePrint + {- ^ + Print button was clicked in print dialog + -} + | PrintOperationResponseCancel + {- ^ + Print dialog was cancelled + -} + | AnotherPrintOperationResponse Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PrintOperationResponse where + fromEnum PrintOperationResponsePrint = 0 + fromEnum PrintOperationResponseCancel = 1 + fromEnum (AnotherPrintOperationResponse k) = k + + toEnum 0 = PrintOperationResponsePrint + toEnum 1 = PrintOperationResponseCancel + toEnum k = AnotherPrintOperationResponse k + +instance P.Ord PrintOperationResponse where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_print_operation_response_get_type" c_webkit_print_operation_response_get_type :: + IO GType + +instance BoxedEnum PrintOperationResponse where + boxedEnumType _ = c_webkit_print_operation_response_get_type + +-- Enum PrintError +{- | +Enum values used to denote the various print errors. +-} +data PrintError = + PrintErrorGeneral + {- ^ + Unspecified error during a print operation + -} + | PrintErrorPrinterNotFound + {- ^ + Selected printer cannot be found + -} + | PrintErrorInvalidPageRange + {- ^ + Invalid page range + -} + | AnotherPrintError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PrintError where + fromEnum PrintErrorGeneral = 599 + fromEnum PrintErrorPrinterNotFound = 500 + fromEnum PrintErrorInvalidPageRange = 501 + fromEnum (AnotherPrintError k) = k + + toEnum 599 = PrintErrorGeneral + toEnum 500 = PrintErrorPrinterNotFound + toEnum 501 = PrintErrorInvalidPageRange + toEnum k = AnotherPrintError k + +instance P.Ord PrintError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass PrintError where + gerrorClassDomain _ = "WebKitPrintError" + +-- | Catch exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchPrintError :: + IO a -> + (PrintError -> GErrorMessage -> IO a) -> + IO a +catchPrintError = catchGErrorJustDomain + +-- | Handle exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handlePrintError :: + (PrintError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handlePrintError = handleGErrorJustDomain + +foreign import ccall "webkit_print_error_get_type" c_webkit_print_error_get_type :: + IO GType + +instance BoxedEnum PrintError where + boxedEnumType _ = c_webkit_print_error_get_type + +-- Enum PolicyError +{- | +Enum values used to denote the various policy errors. +-} +data PolicyError = + PolicyErrorFailed + {- ^ + Generic load failure due to policy error + -} + | PolicyErrorCannotShowMimeType + {- ^ + Load failure due to unsupported mime type + -} + | PolicyErrorCannotShowUri + {- ^ + Load failure due to URI that can not be shown + -} + | PolicyErrorFrameLoadInterruptedByPolicyChange + {- ^ + Load failure due to frame load interruption by policy change + -} + | PolicyErrorCannotUseRestrictedPort + {- ^ + Load failure due to port restriction + -} + | AnotherPolicyError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PolicyError where + fromEnum PolicyErrorFailed = 199 + fromEnum PolicyErrorCannotShowMimeType = 100 + fromEnum PolicyErrorCannotShowUri = 101 + fromEnum PolicyErrorFrameLoadInterruptedByPolicyChange = 102 + fromEnum PolicyErrorCannotUseRestrictedPort = 103 + fromEnum (AnotherPolicyError k) = k + + toEnum 199 = PolicyErrorFailed + toEnum 100 = PolicyErrorCannotShowMimeType + toEnum 101 = PolicyErrorCannotShowUri + toEnum 102 = PolicyErrorFrameLoadInterruptedByPolicyChange + toEnum 103 = PolicyErrorCannotUseRestrictedPort + toEnum k = AnotherPolicyError k + +instance P.Ord PolicyError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass PolicyError where + gerrorClassDomain _ = "WebKitPolicyError" + +-- | Catch exceptions of type `PolicyError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchPolicyError :: + IO a -> + (PolicyError -> GErrorMessage -> IO a) -> + IO a +catchPolicyError = catchGErrorJustDomain + +-- | Handle exceptions of type `PolicyError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handlePolicyError :: + (PolicyError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handlePolicyError = handleGErrorJustDomain + +foreign import ccall "webkit_policy_error_get_type" c_webkit_policy_error_get_type :: + IO GType + +instance BoxedEnum PolicyError where + boxedEnumType _ = c_webkit_policy_error_get_type + +-- Enum PolicyDecisionType +{- | +Enum values used for determining the type of a policy decision during +'GI.WebKit2.Objects.WebView.WebView'::@/decide-policy/@. +-} +data PolicyDecisionType = + PolicyDecisionTypeNavigationAction + {- ^ + This type of policy decision + is requested when WebKit is about to navigate to a new page in either the + main frame or a subframe. Acceptable policy decisions are either + 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' or 'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore'. This + type of policy decision is always a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision'. + -} + | PolicyDecisionTypeNewWindowAction + {- ^ + This type of policy decision + is requested when WebKit is about to create a new window. Acceptable policy + decisions are either 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' or + 'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore'. This type of policy decision is always + a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision'. These decisions are useful for implementing + special actions for new windows, such as forcing the new window to open + in a tab when a keyboard modifier is active or handling a special + target attribute on <a> elements. + -} + | PolicyDecisionTypeResponse + {- ^ + This type of decision is used when WebKit has + received a response for a network resource and is about to start the load. + Note that these resources include all subresources of a page such as images + and stylesheets as well as main documents. Appropriate policy responses to + this decision are 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse', 'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore', + or 'GI.WebKit2.Objects.PolicyDecision.policyDecisionDownload'. This type of policy decision is always + a 'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision'. This decision is useful for forcing + some types of resources to be downloaded rather than rendered in the WebView + or to block the transfer of resources entirely. + -} + | AnotherPolicyDecisionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PolicyDecisionType where + fromEnum PolicyDecisionTypeNavigationAction = 0 + fromEnum PolicyDecisionTypeNewWindowAction = 1 + fromEnum PolicyDecisionTypeResponse = 2 + fromEnum (AnotherPolicyDecisionType k) = k + + toEnum 0 = PolicyDecisionTypeNavigationAction + toEnum 1 = PolicyDecisionTypeNewWindowAction + toEnum 2 = PolicyDecisionTypeResponse + toEnum k = AnotherPolicyDecisionType k + +instance P.Ord PolicyDecisionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_policy_decision_type_get_type" c_webkit_policy_decision_type_get_type :: + IO GType + +instance BoxedEnum PolicyDecisionType where + boxedEnumType _ = c_webkit_policy_decision_type_get_type + +-- Enum PluginError +{- | +Enum values used to denote the various plugin errors. +-} +data PluginError = + PluginErrorFailed + {- ^ + Generic plugin load failure + -} + | PluginErrorCannotFindPlugin + {- ^ + Load failure due to missing plugin + -} + | PluginErrorCannotLoadPlugin + {- ^ + Load failure due to inability to load plugin + -} + | PluginErrorJavaUnavailable + {- ^ + Load failure due to missing Java support that is required to load plugin + -} + | PluginErrorConnectionCancelled + {- ^ + Load failure due to connection cancellation + -} + | PluginErrorWillHandleLoad + {- ^ + Load failure since plugin handles the load + -} + | AnotherPluginError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PluginError where + fromEnum PluginErrorFailed = 299 + fromEnum PluginErrorCannotFindPlugin = 200 + fromEnum PluginErrorCannotLoadPlugin = 201 + fromEnum PluginErrorJavaUnavailable = 202 + fromEnum PluginErrorConnectionCancelled = 203 + fromEnum PluginErrorWillHandleLoad = 204 + fromEnum (AnotherPluginError k) = k + + toEnum 299 = PluginErrorFailed + toEnum 200 = PluginErrorCannotFindPlugin + toEnum 201 = PluginErrorCannotLoadPlugin + toEnum 202 = PluginErrorJavaUnavailable + toEnum 203 = PluginErrorConnectionCancelled + toEnum 204 = PluginErrorWillHandleLoad + toEnum k = AnotherPluginError k + +instance P.Ord PluginError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass PluginError where + gerrorClassDomain _ = "WebKitPluginError" + +-- | Catch exceptions of type `PluginError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchPluginError :: + IO a -> + (PluginError -> GErrorMessage -> IO a) -> + IO a +catchPluginError = catchGErrorJustDomain + +-- | Handle exceptions of type `PluginError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handlePluginError :: + (PluginError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handlePluginError = handleGErrorJustDomain + +foreign import ccall "webkit_plugin_error_get_type" c_webkit_plugin_error_get_type :: + IO GType + +instance BoxedEnum PluginError where + boxedEnumType _ = c_webkit_plugin_error_get_type + +-- Enum NetworkProxyMode +{- | +Enum values used to set the network proxy mode. + +/Since: 2.16/ +-} +data NetworkProxyMode = + NetworkProxyModeDefault + {- ^ + Use the default proxy of the system. + -} + | NetworkProxyModeNoProxy + {- ^ + Do not use any proxy. + -} + | NetworkProxyModeCustom + {- ^ + Use custom proxy settings. + -} + | AnotherNetworkProxyMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NetworkProxyMode where + fromEnum NetworkProxyModeDefault = 0 + fromEnum NetworkProxyModeNoProxy = 1 + fromEnum NetworkProxyModeCustom = 2 + fromEnum (AnotherNetworkProxyMode k) = k + + toEnum 0 = NetworkProxyModeDefault + toEnum 1 = NetworkProxyModeNoProxy + toEnum 2 = NetworkProxyModeCustom + toEnum k = AnotherNetworkProxyMode k + +instance P.Ord NetworkProxyMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_network_proxy_mode_get_type" c_webkit_network_proxy_mode_get_type :: + IO GType + +instance BoxedEnum NetworkProxyMode where + boxedEnumType _ = c_webkit_network_proxy_mode_get_type + +-- Enum NetworkError +{- | +Enum values used to denote the various network errors. +-} +data NetworkError = + NetworkErrorFailed + {- ^ + Generic load failure + -} + | NetworkErrorTransport + {- ^ + Load failure due to transport error + -} + | NetworkErrorUnknownProtocol + {- ^ + Load failure due to unknown protocol + -} + | NetworkErrorCancelled + {- ^ + Load failure due to cancellation + -} + | NetworkErrorFileDoesNotExist + {- ^ + Load failure due to missing file + -} + | AnotherNetworkError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NetworkError where + fromEnum NetworkErrorFailed = 399 + fromEnum NetworkErrorTransport = 300 + fromEnum NetworkErrorUnknownProtocol = 301 + fromEnum NetworkErrorCancelled = 302 + fromEnum NetworkErrorFileDoesNotExist = 303 + fromEnum (AnotherNetworkError k) = k + + toEnum 399 = NetworkErrorFailed + toEnum 300 = NetworkErrorTransport + toEnum 301 = NetworkErrorUnknownProtocol + toEnum 302 = NetworkErrorCancelled + toEnum 303 = NetworkErrorFileDoesNotExist + toEnum k = AnotherNetworkError k + +instance P.Ord NetworkError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass NetworkError where + gerrorClassDomain _ = "WebKitNetworkError" + +-- | Catch exceptions of type `NetworkError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchNetworkError :: + IO a -> + (NetworkError -> GErrorMessage -> IO a) -> + IO a +catchNetworkError = catchGErrorJustDomain + +-- | Handle exceptions of type `NetworkError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleNetworkError :: + (NetworkError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleNetworkError = handleGErrorJustDomain + +foreign import ccall "webkit_network_error_get_type" c_webkit_network_error_get_type :: + IO GType + +instance BoxedEnum NetworkError where + boxedEnumType _ = c_webkit_network_error_get_type + +-- Enum NavigationType +{- | +Enum values used to denote the various navigation types. +-} +data NavigationType = + NavigationTypeLinkClicked + {- ^ + The navigation was triggered by clicking a link. + -} + | NavigationTypeFormSubmitted + {- ^ + The navigation was triggered by submitting a form. + -} + | NavigationTypeBackForward + {- ^ + The navigation was triggered by navigating forward or backward. + -} + | NavigationTypeReload + {- ^ + The navigation was triggered by reloading. + -} + | NavigationTypeFormResubmitted + {- ^ + The navigation was triggered by resubmitting a form. + -} + | NavigationTypeOther + {- ^ + The navigation was triggered by some other action. + -} + | AnotherNavigationType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NavigationType where + fromEnum NavigationTypeLinkClicked = 0 + fromEnum NavigationTypeFormSubmitted = 1 + fromEnum NavigationTypeBackForward = 2 + fromEnum NavigationTypeReload = 3 + fromEnum NavigationTypeFormResubmitted = 4 + fromEnum NavigationTypeOther = 5 + fromEnum (AnotherNavigationType k) = k + + toEnum 0 = NavigationTypeLinkClicked + toEnum 1 = NavigationTypeFormSubmitted + toEnum 2 = NavigationTypeBackForward + toEnum 3 = NavigationTypeReload + toEnum 4 = NavigationTypeFormResubmitted + toEnum 5 = NavigationTypeOther + toEnum k = AnotherNavigationType k + +instance P.Ord NavigationType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_navigation_type_get_type" c_webkit_navigation_type_get_type :: + IO GType + +instance BoxedEnum NavigationType where + boxedEnumType _ = c_webkit_navigation_type_get_type + +-- Enum LoadEvent +{- | +Enum values used to denote the different events that happen during a +'GI.WebKit2.Objects.WebView.WebView' load operation. +-} +data LoadEvent = + LoadEventStarted + {- ^ + A new load request has been made. + No data has been received yet, empty structures have + been allocated to perform the load; the load may still + fail due to transport issues such as not being able to + resolve a name, or connect to a port. + -} + | LoadEventRedirected + {- ^ + A provisional data source received + a server redirect. + -} + | LoadEventCommitted + {- ^ + The content started arriving for a page load. + The necessary transport requirements are established, and the + load is being performed. + -} + | LoadEventFinished + {- ^ + Load completed. All resources are done loading + or there was an error during the load operation. + -} + | AnotherLoadEvent Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum LoadEvent where + fromEnum LoadEventStarted = 0 + fromEnum LoadEventRedirected = 1 + fromEnum LoadEventCommitted = 2 + fromEnum LoadEventFinished = 3 + fromEnum (AnotherLoadEvent k) = k + + toEnum 0 = LoadEventStarted + toEnum 1 = LoadEventRedirected + toEnum 2 = LoadEventCommitted + toEnum 3 = LoadEventFinished + toEnum k = AnotherLoadEvent k + +instance P.Ord LoadEvent where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_load_event_get_type" c_webkit_load_event_get_type :: + IO GType + +instance BoxedEnum LoadEvent where + boxedEnumType _ = c_webkit_load_event_get_type + +-- Enum JavascriptError +{- | +Enum values used to denote errors happening when executing JavaScript +-} +data JavascriptError = + JavascriptErrorFailed + {- ^ + An exception was raised in JavaScript execution + -} + | AnotherJavascriptError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum JavascriptError where + fromEnum JavascriptErrorFailed = 699 + fromEnum (AnotherJavascriptError k) = k + + toEnum 699 = JavascriptErrorFailed + toEnum k = AnotherJavascriptError k + +instance P.Ord JavascriptError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass JavascriptError where + gerrorClassDomain _ = "WebKitJavascriptError" + +-- | Catch exceptions of type `JavascriptError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchJavascriptError :: + IO a -> + (JavascriptError -> GErrorMessage -> IO a) -> + IO a +catchJavascriptError = catchGErrorJustDomain + +-- | Handle exceptions of type `JavascriptError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleJavascriptError :: + (JavascriptError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleJavascriptError = handleGErrorJustDomain + +foreign import ccall "webkit_javascript_error_get_type" c_webkit_javascript_error_get_type :: + IO GType + +instance BoxedEnum JavascriptError where + boxedEnumType _ = c_webkit_javascript_error_get_type + +-- Enum InsecureContentEvent +{- | +Enum values used to denote the different events which can trigger +the detection of insecure content. +-} +data InsecureContentEvent = + InsecureContentEventRun + {- ^ + Insecure content has been detected by + trying to execute any kind of logic (e.g. a script) from an + untrusted source. + -} + | InsecureContentEventDisplayed + {- ^ + Insecure content has been + detected by trying to display any kind of resource (e.g. an image) + from an untrusted source. + -} + | AnotherInsecureContentEvent Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum InsecureContentEvent where + fromEnum InsecureContentEventRun = 0 + fromEnum InsecureContentEventDisplayed = 1 + fromEnum (AnotherInsecureContentEvent k) = k + + toEnum 0 = InsecureContentEventRun + toEnum 1 = InsecureContentEventDisplayed + toEnum k = AnotherInsecureContentEvent k + +instance P.Ord InsecureContentEvent where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_insecure_content_event_get_type" c_webkit_insecure_content_event_get_type :: + IO GType + +instance BoxedEnum InsecureContentEvent where + boxedEnumType _ = c_webkit_insecure_content_event_get_type + +-- Enum HardwareAccelerationPolicy +{- | +Enum values used for determining the hardware acceleration policy. + +/Since: 2.16/ +-} +data HardwareAccelerationPolicy = + HardwareAccelerationPolicyOnDemand + {- ^ + Hardware acceleration is enabled\/disabled as request by web contents. + -} + | HardwareAccelerationPolicyAlways + {- ^ + Hardware acceleration is always enabled, even for websites not requesting it. + -} + | HardwareAccelerationPolicyNever + {- ^ + Hardware acceleration is always disabled, even for websites requesting it. + -} + | AnotherHardwareAccelerationPolicy Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum HardwareAccelerationPolicy where + fromEnum HardwareAccelerationPolicyOnDemand = 0 + fromEnum HardwareAccelerationPolicyAlways = 1 + fromEnum HardwareAccelerationPolicyNever = 2 + fromEnum (AnotherHardwareAccelerationPolicy k) = k + + toEnum 0 = HardwareAccelerationPolicyOnDemand + toEnum 1 = HardwareAccelerationPolicyAlways + toEnum 2 = HardwareAccelerationPolicyNever + toEnum k = AnotherHardwareAccelerationPolicy k + +instance P.Ord HardwareAccelerationPolicy where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_hardware_acceleration_policy_get_type" c_webkit_hardware_acceleration_policy_get_type :: + IO GType + +instance BoxedEnum HardwareAccelerationPolicy where + boxedEnumType _ = c_webkit_hardware_acceleration_policy_get_type + +-- Enum FaviconDatabaseError +{- | +Enum values used to denote the various errors related to the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase'. +-} +data FaviconDatabaseError = + FaviconDatabaseErrorNotInitialized + {- ^ + The 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' has not been initialized yet + -} + | FaviconDatabaseErrorFaviconNotFound + {- ^ + There is not an icon available for the requested URL + -} + | FaviconDatabaseErrorFaviconUnknown + {- ^ + There might be an icon for the requested URL, but its data is unknown at the moment + -} + | AnotherFaviconDatabaseError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FaviconDatabaseError where + fromEnum FaviconDatabaseErrorNotInitialized = 0 + fromEnum FaviconDatabaseErrorFaviconNotFound = 1 + fromEnum FaviconDatabaseErrorFaviconUnknown = 2 + fromEnum (AnotherFaviconDatabaseError k) = k + + toEnum 0 = FaviconDatabaseErrorNotInitialized + toEnum 1 = FaviconDatabaseErrorFaviconNotFound + toEnum 2 = FaviconDatabaseErrorFaviconUnknown + toEnum k = AnotherFaviconDatabaseError k + +instance P.Ord FaviconDatabaseError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass FaviconDatabaseError where + gerrorClassDomain _ = "WebKitFaviconDatabaseError" + +-- | Catch exceptions of type `FaviconDatabaseError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchFaviconDatabaseError :: + IO a -> + (FaviconDatabaseError -> GErrorMessage -> IO a) -> + IO a +catchFaviconDatabaseError = catchGErrorJustDomain + +-- | Handle exceptions of type `FaviconDatabaseError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleFaviconDatabaseError :: + (FaviconDatabaseError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleFaviconDatabaseError = handleGErrorJustDomain + +foreign import ccall "webkit_favicon_database_error_get_type" c_webkit_favicon_database_error_get_type :: + IO GType + +instance BoxedEnum FaviconDatabaseError where + boxedEnumType _ = c_webkit_favicon_database_error_get_type + +-- Enum DownloadError +{- | +Enum values used to denote the various download errors. +-} +data DownloadError = + DownloadErrorNetwork + {- ^ + Download failure due to network error + -} + | DownloadErrorCancelledByUser + {- ^ + Download was cancelled by user + -} + | DownloadErrorDestination + {- ^ + Download failure due to destination error + -} + | AnotherDownloadError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum DownloadError where + fromEnum DownloadErrorNetwork = 499 + fromEnum DownloadErrorCancelledByUser = 400 + fromEnum DownloadErrorDestination = 401 + fromEnum (AnotherDownloadError k) = k + + toEnum 499 = DownloadErrorNetwork + toEnum 400 = DownloadErrorCancelledByUser + toEnum 401 = DownloadErrorDestination + toEnum k = AnotherDownloadError k + +instance P.Ord DownloadError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass DownloadError where + gerrorClassDomain _ = "WebKitDownloadError" + +-- | Catch exceptions of type `DownloadError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchDownloadError :: + IO a -> + (DownloadError -> GErrorMessage -> IO a) -> + IO a +catchDownloadError = catchGErrorJustDomain + +-- | Handle exceptions of type `DownloadError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +handleDownloadError :: + (DownloadError -> GErrorMessage -> IO a) -> + IO a -> + IO a +handleDownloadError = handleGErrorJustDomain + +foreign import ccall "webkit_download_error_get_type" c_webkit_download_error_get_type :: + IO GType + +instance BoxedEnum DownloadError where + boxedEnumType _ = c_webkit_download_error_get_type + +-- Enum CredentialPersistence +{- | +Enum values representing the duration for which a credential persists. + +/Since: 2.2/ +-} +data CredentialPersistence = + CredentialPersistenceNone + {- ^ + Credential does not persist + -} + | CredentialPersistenceForSession + {- ^ + Credential persists for session only + -} + | CredentialPersistencePermanent + {- ^ + Credential persists permanently + -} + | AnotherCredentialPersistence Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CredentialPersistence where + fromEnum CredentialPersistenceNone = 0 + fromEnum CredentialPersistenceForSession = 1 + fromEnum CredentialPersistencePermanent = 2 + fromEnum (AnotherCredentialPersistence k) = k + + toEnum 0 = CredentialPersistenceNone + toEnum 1 = CredentialPersistenceForSession + toEnum 2 = CredentialPersistencePermanent + toEnum k = AnotherCredentialPersistence k + +instance P.Ord CredentialPersistence where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_credential_persistence_get_type" c_webkit_credential_persistence_get_type :: + IO GType + +instance BoxedEnum CredentialPersistence where + boxedEnumType _ = c_webkit_credential_persistence_get_type + +-- Enum CookiePersistentStorage +{- | +Enum values used to denote the cookie persistent storage types. +-} +data CookiePersistentStorage = + CookiePersistentStorageText + {- ^ + Cookies are stored in a text + file in the Mozilla \"cookies.txt\" format. + -} + | CookiePersistentStorageSqlite + {- ^ + Cookies are stored in a SQLite + file in the current Mozilla format. + -} + | AnotherCookiePersistentStorage Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CookiePersistentStorage where + fromEnum CookiePersistentStorageText = 0 + fromEnum CookiePersistentStorageSqlite = 1 + fromEnum (AnotherCookiePersistentStorage k) = k + + toEnum 0 = CookiePersistentStorageText + toEnum 1 = CookiePersistentStorageSqlite + toEnum k = AnotherCookiePersistentStorage k + +instance P.Ord CookiePersistentStorage where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_cookie_persistent_storage_get_type" c_webkit_cookie_persistent_storage_get_type :: + IO GType + +instance BoxedEnum CookiePersistentStorage where + boxedEnumType _ = c_webkit_cookie_persistent_storage_get_type + +-- Enum CookieAcceptPolicy +{- | +Enum values used to denote the cookie acceptance policies. +-} +data CookieAcceptPolicy = + CookieAcceptPolicyAlways + {- ^ + Accept all cookies unconditionally. + -} + | CookieAcceptPolicyNever + {- ^ + Reject all cookies unconditionally. + -} + | CookieAcceptPolicyNoThirdParty + {- ^ + Accept only cookies set by the main document loaded. + -} + | AnotherCookieAcceptPolicy Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CookieAcceptPolicy where + fromEnum CookieAcceptPolicyAlways = 0 + fromEnum CookieAcceptPolicyNever = 1 + fromEnum CookieAcceptPolicyNoThirdParty = 2 + fromEnum (AnotherCookieAcceptPolicy k) = k + + toEnum 0 = CookieAcceptPolicyAlways + toEnum 1 = CookieAcceptPolicyNever + toEnum 2 = CookieAcceptPolicyNoThirdParty + toEnum k = AnotherCookieAcceptPolicy k + +instance P.Ord CookieAcceptPolicy where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_cookie_accept_policy_get_type" c_webkit_cookie_accept_policy_get_type :: + IO GType + +instance BoxedEnum CookieAcceptPolicy where + boxedEnumType _ = c_webkit_cookie_accept_policy_get_type + +-- Enum ContextMenuAction +{- | +Enum values used to denote the stock actions for +'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem'\s +-} +data ContextMenuAction = + ContextMenuActionNoAction + {- ^ + No action, used by separator menu items. + -} + | ContextMenuActionOpenLink + {- ^ + Open current link. + -} + | ContextMenuActionOpenLinkInNewWindow + {- ^ + Open current link in a new window. + -} + | ContextMenuActionDownloadLinkToDisk + {- ^ + Download link destination. + -} + | ContextMenuActionCopyLinkToClipboard + {- ^ + Copy link location to the clipboard. + -} + | ContextMenuActionOpenImageInNewWindow + {- ^ + Open current image in a new window. + -} + | ContextMenuActionDownloadImageToDisk + {- ^ + Download current image. + -} + | ContextMenuActionCopyImageToClipboard + {- ^ + Copy current image to the clipboard. + -} + | ContextMenuActionCopyImageUrlToClipboard + {- ^ + Copy current image location to the clipboard. + -} + | ContextMenuActionOpenFrameInNewWindow + {- ^ + Open current frame in a new window. + -} + | ContextMenuActionGoBack + {- ^ + Load the previous history item. + -} + | ContextMenuActionGoForward + {- ^ + Load the next history item. + -} + | ContextMenuActionStop + {- ^ + Stop any ongoing loading operation. + -} + | ContextMenuActionReload + {- ^ + Reload the contents of current view. + -} + | ContextMenuActionCopy + {- ^ + Copy current selection the clipboard. + -} + | ContextMenuActionCut + {- ^ + Cut current selection to the clipboard. + -} + | ContextMenuActionPaste + {- ^ + Paste clipboard contents. + -} + | ContextMenuActionDelete + {- ^ + Delete current selection. + -} + | ContextMenuActionSelectAll + {- ^ + Select all text. + -} + | ContextMenuActionInputMethods + {- ^ + Input methods menu. + -} + | ContextMenuActionUnicode + {- ^ + Unicode menu. + -} + | ContextMenuActionSpellingGuess + {- ^ + A proposed replacement for a misspelled word. + -} + | ContextMenuActionNoGuessesFound + {- ^ + An indicator that spellchecking found no proposed replacements. + -} + | ContextMenuActionIgnoreSpelling + {- ^ + Causes the spellchecker to ignore the word for this session. + -} + | ContextMenuActionLearnSpelling + {- ^ + Causes the spellchecker to add the word to the dictionary. + -} + | ContextMenuActionIgnoreGrammar + {- ^ + Ignore grammar. + -} + | ContextMenuActionFontMenu + {- ^ + Font options menu. + -} + | ContextMenuActionBold + {- ^ + Bold. + -} + | ContextMenuActionItalic + {- ^ + Italic. + -} + | ContextMenuActionUnderline + {- ^ + Underline. + -} + | ContextMenuActionOutline + {- ^ + Outline. + -} + | ContextMenuActionInspectElement + {- ^ + Open current element in the inspector. + -} + | ContextMenuActionOpenVideoInNewWindow + {- ^ + Open current video element in a new window. + -} + | ContextMenuActionOpenAudioInNewWindow + {- ^ + Open current audio element in a new window. + -} + | ContextMenuActionCopyVideoLinkToClipboard + {- ^ + Copy video link location in to the clipboard. + -} + | ContextMenuActionCopyAudioLinkToClipboard + {- ^ + Copy audio link location in to the clipboard. + -} + | ContextMenuActionToggleMediaControls + {- ^ + Enable or disable media controls. + -} + | ContextMenuActionToggleMediaLoop + {- ^ + Enable or disable media loop. + -} + | ContextMenuActionEnterVideoFullscreen + {- ^ + Show current video element in fullscreen mode. + -} + | ContextMenuActionMediaPlay + {- ^ + Play current media element. + -} + | ContextMenuActionMediaPause + {- ^ + Pause current media element. + -} + | ContextMenuActionMediaMute + {- ^ + Mute current media element. + -} + | ContextMenuActionDownloadVideoToDisk + {- ^ + Download video to disk. Since 2.2 + -} + | ContextMenuActionDownloadAudioToDisk + {- ^ + Download audio to disk. Since 2.2 + -} + | ContextMenuActionCustom + {- ^ + Custom action defined by applications. + -} + | AnotherContextMenuAction Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ContextMenuAction where + fromEnum ContextMenuActionNoAction = 0 + fromEnum ContextMenuActionOpenLink = 1 + fromEnum ContextMenuActionOpenLinkInNewWindow = 2 + fromEnum ContextMenuActionDownloadLinkToDisk = 3 + fromEnum ContextMenuActionCopyLinkToClipboard = 4 + fromEnum ContextMenuActionOpenImageInNewWindow = 5 + fromEnum ContextMenuActionDownloadImageToDisk = 6 + fromEnum ContextMenuActionCopyImageToClipboard = 7 + fromEnum ContextMenuActionCopyImageUrlToClipboard = 8 + fromEnum ContextMenuActionOpenFrameInNewWindow = 9 + fromEnum ContextMenuActionGoBack = 10 + fromEnum ContextMenuActionGoForward = 11 + fromEnum ContextMenuActionStop = 12 + fromEnum ContextMenuActionReload = 13 + fromEnum ContextMenuActionCopy = 14 + fromEnum ContextMenuActionCut = 15 + fromEnum ContextMenuActionPaste = 16 + fromEnum ContextMenuActionDelete = 17 + fromEnum ContextMenuActionSelectAll = 18 + fromEnum ContextMenuActionInputMethods = 19 + fromEnum ContextMenuActionUnicode = 20 + fromEnum ContextMenuActionSpellingGuess = 21 + fromEnum ContextMenuActionNoGuessesFound = 22 + fromEnum ContextMenuActionIgnoreSpelling = 23 + fromEnum ContextMenuActionLearnSpelling = 24 + fromEnum ContextMenuActionIgnoreGrammar = 25 + fromEnum ContextMenuActionFontMenu = 26 + fromEnum ContextMenuActionBold = 27 + fromEnum ContextMenuActionItalic = 28 + fromEnum ContextMenuActionUnderline = 29 + fromEnum ContextMenuActionOutline = 30 + fromEnum ContextMenuActionInspectElement = 31 + fromEnum ContextMenuActionOpenVideoInNewWindow = 32 + fromEnum ContextMenuActionOpenAudioInNewWindow = 33 + fromEnum ContextMenuActionCopyVideoLinkToClipboard = 34 + fromEnum ContextMenuActionCopyAudioLinkToClipboard = 35 + fromEnum ContextMenuActionToggleMediaControls = 36 + fromEnum ContextMenuActionToggleMediaLoop = 37 + fromEnum ContextMenuActionEnterVideoFullscreen = 38 + fromEnum ContextMenuActionMediaPlay = 39 + fromEnum ContextMenuActionMediaPause = 40 + fromEnum ContextMenuActionMediaMute = 41 + fromEnum ContextMenuActionDownloadVideoToDisk = 42 + fromEnum ContextMenuActionDownloadAudioToDisk = 43 + fromEnum ContextMenuActionCustom = 10000 + fromEnum (AnotherContextMenuAction k) = k + + toEnum 0 = ContextMenuActionNoAction + toEnum 1 = ContextMenuActionOpenLink + toEnum 2 = ContextMenuActionOpenLinkInNewWindow + toEnum 3 = ContextMenuActionDownloadLinkToDisk + toEnum 4 = ContextMenuActionCopyLinkToClipboard + toEnum 5 = ContextMenuActionOpenImageInNewWindow + toEnum 6 = ContextMenuActionDownloadImageToDisk + toEnum 7 = ContextMenuActionCopyImageToClipboard + toEnum 8 = ContextMenuActionCopyImageUrlToClipboard + toEnum 9 = ContextMenuActionOpenFrameInNewWindow + toEnum 10 = ContextMenuActionGoBack + toEnum 11 = ContextMenuActionGoForward + toEnum 12 = ContextMenuActionStop + toEnum 13 = ContextMenuActionReload + toEnum 14 = ContextMenuActionCopy + toEnum 15 = ContextMenuActionCut + toEnum 16 = ContextMenuActionPaste + toEnum 17 = ContextMenuActionDelete + toEnum 18 = ContextMenuActionSelectAll + toEnum 19 = ContextMenuActionInputMethods + toEnum 20 = ContextMenuActionUnicode + toEnum 21 = ContextMenuActionSpellingGuess + toEnum 22 = ContextMenuActionNoGuessesFound + toEnum 23 = ContextMenuActionIgnoreSpelling + toEnum 24 = ContextMenuActionLearnSpelling + toEnum 25 = ContextMenuActionIgnoreGrammar + toEnum 26 = ContextMenuActionFontMenu + toEnum 27 = ContextMenuActionBold + toEnum 28 = ContextMenuActionItalic + toEnum 29 = ContextMenuActionUnderline + toEnum 30 = ContextMenuActionOutline + toEnum 31 = ContextMenuActionInspectElement + toEnum 32 = ContextMenuActionOpenVideoInNewWindow + toEnum 33 = ContextMenuActionOpenAudioInNewWindow + toEnum 34 = ContextMenuActionCopyVideoLinkToClipboard + toEnum 35 = ContextMenuActionCopyAudioLinkToClipboard + toEnum 36 = ContextMenuActionToggleMediaControls + toEnum 37 = ContextMenuActionToggleMediaLoop + toEnum 38 = ContextMenuActionEnterVideoFullscreen + toEnum 39 = ContextMenuActionMediaPlay + toEnum 40 = ContextMenuActionMediaPause + toEnum 41 = ContextMenuActionMediaMute + toEnum 42 = ContextMenuActionDownloadVideoToDisk + toEnum 43 = ContextMenuActionDownloadAudioToDisk + toEnum 10000 = ContextMenuActionCustom + toEnum k = AnotherContextMenuAction k + +instance P.Ord ContextMenuAction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_context_menu_action_get_type" c_webkit_context_menu_action_get_type :: + IO GType + +instance BoxedEnum ContextMenuAction where + boxedEnumType _ = c_webkit_context_menu_action_get_type + +-- Enum CacheModel +{- | +Enum values used for determining the 'GI.WebKit2.Objects.WebContext.WebContext' cache model. +-} +data CacheModel = + CacheModelDocumentViewer + {- ^ + Disable the cache completely, which + substantially reduces memory usage. Useful for applications that only + access a single local file, with no navigation to other pages. No remote + resources will be cached. + -} + | CacheModelWebBrowser + {- ^ + Improve document load speed substantially + by caching a very large number of resources and previously viewed content. + -} + | CacheModelDocumentBrowser + {- ^ + A cache model optimized for viewing + a series of local files -- for example, a documentation viewer or a website + designer. WebKit will cache a moderate number of resources. + -} + | AnotherCacheModel Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CacheModel where + fromEnum CacheModelDocumentViewer = 0 + fromEnum CacheModelWebBrowser = 1 + fromEnum CacheModelDocumentBrowser = 2 + fromEnum (AnotherCacheModel k) = k + + toEnum 0 = CacheModelDocumentViewer + toEnum 1 = CacheModelWebBrowser + toEnum 2 = CacheModelDocumentBrowser + toEnum k = AnotherCacheModel k + +instance P.Ord CacheModel where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_cache_model_get_type" c_webkit_cache_model_get_type :: + IO GType + +instance BoxedEnum CacheModel where + boxedEnumType _ = c_webkit_cache_model_get_type + +-- Enum AuthenticationScheme +{- | +Enum values representing the authentication scheme. + +/Since: 2.2/ +-} +data AuthenticationScheme = + AuthenticationSchemeDefault + {- ^ + The default authentication scheme of WebKit. + -} + | AuthenticationSchemeHttpBasic + {- ^ + Basic authentication scheme as defined in RFC 2617. + -} + | AuthenticationSchemeHttpDigest + {- ^ + Digest authentication scheme as defined in RFC 2617. + -} + | AuthenticationSchemeHtmlForm + {- ^ + HTML Form authentication. + -} + | AuthenticationSchemeNtlm + {- ^ + NTLM Microsoft proprietary authentication scheme. + -} + | AuthenticationSchemeNegotiate + {- ^ + Negotiate (or SPNEGO) authentication scheme as defined in RFC 4559. + -} + | AuthenticationSchemeClientCertificateRequested + {- ^ + Client Certificate Authentication (see RFC 2246). + -} + | AuthenticationSchemeServerTrustEvaluationRequested + {- ^ + Server Trust Authentication. + -} + | AuthenticationSchemeUnknown + {- ^ + Authentication scheme unknown. + -} + | AnotherAuthenticationScheme Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum AuthenticationScheme where + fromEnum AuthenticationSchemeDefault = 1 + fromEnum AuthenticationSchemeHttpBasic = 2 + fromEnum AuthenticationSchemeHttpDigest = 3 + fromEnum AuthenticationSchemeHtmlForm = 4 + fromEnum AuthenticationSchemeNtlm = 5 + fromEnum AuthenticationSchemeNegotiate = 6 + fromEnum AuthenticationSchemeClientCertificateRequested = 7 + fromEnum AuthenticationSchemeServerTrustEvaluationRequested = 8 + fromEnum AuthenticationSchemeUnknown = 100 + fromEnum (AnotherAuthenticationScheme k) = k + + toEnum 1 = AuthenticationSchemeDefault + toEnum 2 = AuthenticationSchemeHttpBasic + toEnum 3 = AuthenticationSchemeHttpDigest + toEnum 4 = AuthenticationSchemeHtmlForm + toEnum 5 = AuthenticationSchemeNtlm + toEnum 6 = AuthenticationSchemeNegotiate + toEnum 7 = AuthenticationSchemeClientCertificateRequested + toEnum 8 = AuthenticationSchemeServerTrustEvaluationRequested + toEnum 100 = AuthenticationSchemeUnknown + toEnum k = AnotherAuthenticationScheme k + +instance P.Ord AuthenticationScheme where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_authentication_scheme_get_type" c_webkit_authentication_scheme_get_type :: + IO GType + +instance BoxedEnum AuthenticationScheme where + boxedEnumType _ = c_webkit_authentication_scheme_get_type + + diff --git a/GI/WebKit2/Enums.hs-boot b/GI/WebKit2/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Enums.hs-boot @@ -0,0 +1,117 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Enums 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 + +data WebProcessTerminationReason +instance P.Enum WebProcessTerminationReason where +instance BoxedEnum WebProcessTerminationReason where +data UserStyleLevel +instance P.Enum UserStyleLevel where +instance BoxedEnum UserStyleLevel where +data UserScriptInjectionTime +instance P.Enum UserScriptInjectionTime where +instance BoxedEnum UserScriptInjectionTime where +data UserContentInjectedFrames +instance P.Enum UserContentInjectedFrames where +instance BoxedEnum UserContentInjectedFrames where +data UserContentFilterError +instance P.Enum UserContentFilterError where +instance BoxedEnum UserContentFilterError where +data TLSErrorsPolicy +instance P.Enum TLSErrorsPolicy where +instance BoxedEnum TLSErrorsPolicy where +data SnapshotRegion +instance P.Enum SnapshotRegion where +instance BoxedEnum SnapshotRegion where +data SnapshotError +instance P.Enum SnapshotError where +instance BoxedEnum SnapshotError where +data ScriptDialogType +instance P.Enum ScriptDialogType where +instance BoxedEnum ScriptDialogType where +data SaveMode +instance P.Enum SaveMode where +instance BoxedEnum SaveMode where +data ProcessModel +instance P.Enum ProcessModel where +instance BoxedEnum ProcessModel where +data PrintOperationResponse +instance P.Enum PrintOperationResponse where +instance BoxedEnum PrintOperationResponse where +data PrintError +instance P.Enum PrintError where +instance BoxedEnum PrintError where +data PolicyError +instance P.Enum PolicyError where +instance BoxedEnum PolicyError where +data PolicyDecisionType +instance P.Enum PolicyDecisionType where +instance BoxedEnum PolicyDecisionType where +data PluginError +instance P.Enum PluginError where +instance BoxedEnum PluginError where +data NetworkProxyMode +instance P.Enum NetworkProxyMode where +instance BoxedEnum NetworkProxyMode where +data NetworkError +instance P.Enum NetworkError where +instance BoxedEnum NetworkError where +data NavigationType +instance P.Enum NavigationType where +instance BoxedEnum NavigationType where +data LoadEvent +instance P.Enum LoadEvent where +instance BoxedEnum LoadEvent where +data JavascriptError +instance P.Enum JavascriptError where +instance BoxedEnum JavascriptError where +data InsecureContentEvent +instance P.Enum InsecureContentEvent where +instance BoxedEnum InsecureContentEvent where +data HardwareAccelerationPolicy +instance P.Enum HardwareAccelerationPolicy where +instance BoxedEnum HardwareAccelerationPolicy where +data FaviconDatabaseError +instance P.Enum FaviconDatabaseError where +instance BoxedEnum FaviconDatabaseError where +data DownloadError +instance P.Enum DownloadError where +instance BoxedEnum DownloadError where +data CredentialPersistence +instance P.Enum CredentialPersistence where +instance BoxedEnum CredentialPersistence where +data CookiePersistentStorage +instance P.Enum CookiePersistentStorage where +instance BoxedEnum CookiePersistentStorage where +data CookieAcceptPolicy +instance P.Enum CookieAcceptPolicy where +instance BoxedEnum CookieAcceptPolicy where +data ContextMenuAction +instance P.Enum ContextMenuAction where +instance BoxedEnum ContextMenuAction where +data CacheModel +instance P.Enum CacheModel where +instance BoxedEnum CacheModel where +data AuthenticationScheme +instance P.Enum AuthenticationScheme where +instance BoxedEnum AuthenticationScheme where diff --git a/GI/WebKit2/Flags.hs b/GI/WebKit2/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Flags.hs @@ -0,0 +1,394 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Flags + ( + + -- * Flags +-- ** EditorTypingAttributes #flag:EditorTypingAttributes# + + EditorTypingAttributes(..) , + + +-- ** FindOptions #flag:FindOptions# + + FindOptions(..) , + + +-- ** HitTestResultContext #flag:HitTestResultContext# + + HitTestResultContext(..) , + + +-- ** SnapshotOptions #flag:SnapshotOptions# + + SnapshotOptions(..) , + + +-- ** WebsiteDataTypes #flag:WebsiteDataTypes# + + WebsiteDataTypes(..) , + + + + + ) 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 + + +-- Flags WebsiteDataTypes +{- | +Enum values with flags representing types of Website data. + +/Since: 2.16/ +-} +data WebsiteDataTypes = + WebsiteDataTypesMemoryCache + {- ^ + Memory cache. + -} + | WebsiteDataTypesDiskCache + {- ^ + HTTP disk cache. + -} + | WebsiteDataTypesOfflineApplicationCache + {- ^ + Offline web application cache. + -} + | WebsiteDataTypesSessionStorage + {- ^ + Session storage data. + -} + | WebsiteDataTypesLocalStorage + {- ^ + Local storage data. + -} + | WebsiteDataTypesWebsqlDatabases + {- ^ + WebSQL databases. + -} + | WebsiteDataTypesIndexeddbDatabases + {- ^ + IndexedDB databases. + -} + | WebsiteDataTypesPluginData + {- ^ + Plugins data. + -} + | WebsiteDataTypesCookies + {- ^ + Cookies. + -} + | WebsiteDataTypesDeviceIdHashSalt + {- ^ + Hash salt used to generate the device ids used by webpages. Since 2.24 + -} + | WebsiteDataTypesAll + {- ^ + All types. + -} + | AnotherWebsiteDataTypes Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum WebsiteDataTypes where + fromEnum WebsiteDataTypesMemoryCache = 1 + fromEnum WebsiteDataTypesDiskCache = 2 + fromEnum WebsiteDataTypesOfflineApplicationCache = 4 + fromEnum WebsiteDataTypesSessionStorage = 8 + fromEnum WebsiteDataTypesLocalStorage = 16 + fromEnum WebsiteDataTypesWebsqlDatabases = 32 + fromEnum WebsiteDataTypesIndexeddbDatabases = 64 + fromEnum WebsiteDataTypesPluginData = 128 + fromEnum WebsiteDataTypesCookies = 256 + fromEnum WebsiteDataTypesDeviceIdHashSalt = 512 + fromEnum WebsiteDataTypesAll = 1023 + fromEnum (AnotherWebsiteDataTypes k) = k + + toEnum 1 = WebsiteDataTypesMemoryCache + toEnum 2 = WebsiteDataTypesDiskCache + toEnum 4 = WebsiteDataTypesOfflineApplicationCache + toEnum 8 = WebsiteDataTypesSessionStorage + toEnum 16 = WebsiteDataTypesLocalStorage + toEnum 32 = WebsiteDataTypesWebsqlDatabases + toEnum 64 = WebsiteDataTypesIndexeddbDatabases + toEnum 128 = WebsiteDataTypesPluginData + toEnum 256 = WebsiteDataTypesCookies + toEnum 512 = WebsiteDataTypesDeviceIdHashSalt + toEnum 1023 = WebsiteDataTypesAll + toEnum k = AnotherWebsiteDataTypes k + +instance P.Ord WebsiteDataTypes where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_website_data_types_get_type" c_webkit_website_data_types_get_type :: + IO GType + +instance BoxedFlags WebsiteDataTypes where + boxedFlagsType _ = c_webkit_website_data_types_get_type + +instance IsGFlag WebsiteDataTypes + +-- Flags SnapshotOptions +{- | +Enum values used to specify options when taking a snapshot +from a 'GI.WebKit2.Objects.WebView.WebView'. +-} +data SnapshotOptions = + SnapshotOptionsNone + {- ^ + Do not include any special options. + -} + | SnapshotOptionsIncludeSelectionHighlighting + {- ^ + Whether to include in the + snapshot the highlight of the selected content. + -} + | SnapshotOptionsTransparentBackground + {- ^ + Do not fill the background with white before + rendering the snapshot. Since 2.8 + -} + | AnotherSnapshotOptions Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SnapshotOptions where + fromEnum SnapshotOptionsNone = 0 + fromEnum SnapshotOptionsIncludeSelectionHighlighting = 1 + fromEnum SnapshotOptionsTransparentBackground = 2 + fromEnum (AnotherSnapshotOptions k) = k + + toEnum 0 = SnapshotOptionsNone + toEnum 1 = SnapshotOptionsIncludeSelectionHighlighting + toEnum 2 = SnapshotOptionsTransparentBackground + toEnum k = AnotherSnapshotOptions k + +instance P.Ord SnapshotOptions where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_snapshot_options_get_type" c_webkit_snapshot_options_get_type :: + IO GType + +instance BoxedFlags SnapshotOptions where + boxedFlagsType _ = c_webkit_snapshot_options_get_type + +instance IsGFlag SnapshotOptions + +-- Flags HitTestResultContext +{- | +Enum values with flags representing the context of a 'GI.WebKit2.Objects.HitTestResult.HitTestResult'. +-} +data HitTestResultContext = + HitTestResultContextDocument + {- ^ + anywhere in the document. + -} + | HitTestResultContextLink + {- ^ + a hyperlink element. + -} + | HitTestResultContextImage + {- ^ + an image element. + -} + | HitTestResultContextMedia + {- ^ + a video or audio element. + -} + | HitTestResultContextEditable + {- ^ + an editable element + -} + | HitTestResultContextScrollbar + {- ^ + a scrollbar element. + -} + | HitTestResultContextSelection + {- ^ + a selected element. Since 2.8 + -} + | AnotherHitTestResultContext Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum HitTestResultContext where + fromEnum HitTestResultContextDocument = 2 + fromEnum HitTestResultContextLink = 4 + fromEnum HitTestResultContextImage = 8 + fromEnum HitTestResultContextMedia = 16 + fromEnum HitTestResultContextEditable = 32 + fromEnum HitTestResultContextScrollbar = 64 + fromEnum HitTestResultContextSelection = 128 + fromEnum (AnotherHitTestResultContext k) = k + + toEnum 2 = HitTestResultContextDocument + toEnum 4 = HitTestResultContextLink + toEnum 8 = HitTestResultContextImage + toEnum 16 = HitTestResultContextMedia + toEnum 32 = HitTestResultContextEditable + toEnum 64 = HitTestResultContextScrollbar + toEnum 128 = HitTestResultContextSelection + toEnum k = AnotherHitTestResultContext k + +instance P.Ord HitTestResultContext where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_hit_test_result_context_get_type" c_webkit_hit_test_result_context_get_type :: + IO GType + +instance BoxedFlags HitTestResultContext where + boxedFlagsType _ = c_webkit_hit_test_result_context_get_type + +instance IsGFlag HitTestResultContext + +-- Flags FindOptions +{- | +Enum values used to specify search options. +-} +data FindOptions = + FindOptionsNone + {- ^ + no search flags, this means a case + sensitive, no wrap, forward only search. + -} + | FindOptionsCaseInsensitive + {- ^ + case insensitive search. + -} + | FindOptionsAtWordStarts + {- ^ + search text only at the + begining of the words. + -} + | FindOptionsTreatMedialCapitalAsWordStart + {- ^ + treat + capital letters in the middle of words as word start. + -} + | FindOptionsBackwards + {- ^ + search backwards. + -} + | FindOptionsWrapAround + {- ^ + if not present search will stop + at the end of the document. + -} + | AnotherFindOptions Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FindOptions where + fromEnum FindOptionsNone = 0 + fromEnum FindOptionsCaseInsensitive = 1 + fromEnum FindOptionsAtWordStarts = 2 + fromEnum FindOptionsTreatMedialCapitalAsWordStart = 4 + fromEnum FindOptionsBackwards = 8 + fromEnum FindOptionsWrapAround = 16 + fromEnum (AnotherFindOptions k) = k + + toEnum 0 = FindOptionsNone + toEnum 1 = FindOptionsCaseInsensitive + toEnum 2 = FindOptionsAtWordStarts + toEnum 4 = FindOptionsTreatMedialCapitalAsWordStart + toEnum 8 = FindOptionsBackwards + toEnum 16 = FindOptionsWrapAround + toEnum k = AnotherFindOptions k + +instance P.Ord FindOptions where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_find_options_get_type" c_webkit_find_options_get_type :: + IO GType + +instance BoxedFlags FindOptions where + boxedFlagsType _ = c_webkit_find_options_get_type + +instance IsGFlag FindOptions + +-- Flags EditorTypingAttributes +{- | +Enum values with flags representing typing attributes. + +/Since: 2.10/ +-} +data EditorTypingAttributes = + EditorTypingAttributesNone + {- ^ + No typing attributes. + -} + | EditorTypingAttributesBold + {- ^ + Bold typing attribute. + -} + | EditorTypingAttributesItalic + {- ^ + Italic typing attribute. + -} + | EditorTypingAttributesUnderline + {- ^ + Underline typing attribute. + -} + | EditorTypingAttributesStrikethrough + {- ^ + Strikethrough typing attribute. + -} + | AnotherEditorTypingAttributes Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum EditorTypingAttributes where + fromEnum EditorTypingAttributesNone = 2 + fromEnum EditorTypingAttributesBold = 4 + fromEnum EditorTypingAttributesItalic = 8 + fromEnum EditorTypingAttributesUnderline = 16 + fromEnum EditorTypingAttributesStrikethrough = 32 + fromEnum (AnotherEditorTypingAttributes k) = k + + toEnum 2 = EditorTypingAttributesNone + toEnum 4 = EditorTypingAttributesBold + toEnum 8 = EditorTypingAttributesItalic + toEnum 16 = EditorTypingAttributesUnderline + toEnum 32 = EditorTypingAttributesStrikethrough + toEnum k = AnotherEditorTypingAttributes k + +instance P.Ord EditorTypingAttributes where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "webkit_editor_typing_attributes_get_type" c_webkit_editor_typing_attributes_get_type :: + IO GType + +instance BoxedFlags EditorTypingAttributes where + boxedFlagsType _ = c_webkit_editor_typing_attributes_get_type + +instance IsGFlag EditorTypingAttributes + + diff --git a/GI/WebKit2/Flags.hs-boot b/GI/WebKit2/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Flags.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Flags 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 + +data WebsiteDataTypes +instance P.Enum WebsiteDataTypes where +instance BoxedFlags WebsiteDataTypes where +instance IsGFlag WebsiteDataTypes +data SnapshotOptions +instance P.Enum SnapshotOptions where +instance BoxedFlags SnapshotOptions where +instance IsGFlag SnapshotOptions +data HitTestResultContext +instance P.Enum HitTestResultContext where +instance BoxedFlags HitTestResultContext where +instance IsGFlag HitTestResultContext +data FindOptions +instance P.Enum FindOptions where +instance BoxedFlags FindOptions where +instance IsGFlag FindOptions +data EditorTypingAttributes +instance P.Enum EditorTypingAttributes where +instance BoxedFlags EditorTypingAttributes where +instance IsGFlag EditorTypingAttributes diff --git a/GI/WebKit2/Functions.hs b/GI/WebKit2/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Functions.hs @@ -0,0 +1,254 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Functions + ( + + -- * Methods +-- ** getMajorVersion #method:getMajorVersion# + + getMajorVersion , + + +-- ** getMicroVersion #method:getMicroVersion# + + getMicroVersion , + + +-- ** getMinorVersion #method:getMinorVersion# + + getMinorVersion , + + +-- ** uriForDisplay #method:uriForDisplay# + + uriForDisplay , + + +-- ** userMediaPermissionIsForAudioDevice #method:userMediaPermissionIsForAudioDevice# + + userMediaPermissionIsForAudioDevice , + + +-- ** userMediaPermissionIsForVideoDevice #method:userMediaPermissionIsForVideoDevice# + + userMediaPermissionIsForVideoDevice , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.UserMediaPermissionRequest as WebKit2.UserMediaPermissionRequest + +-- function webkit_user_media_permission_is_for_video_device +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "UserMediaPermissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserMediaPermissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_media_permission_is_for_video_device" webkit_user_media_permission_is_for_video_device :: + Ptr WebKit2.UserMediaPermissionRequest.UserMediaPermissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "UserMediaPermissionRequest"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 2.8/ +-} +userMediaPermissionIsForVideoDevice :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.UserMediaPermissionRequest.IsUserMediaPermissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.UserMediaPermissionRequest.UserMediaPermissionRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if access to a video device was requested. -} +userMediaPermissionIsForVideoDevice request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_user_media_permission_is_for_video_device request' + let result' = (/= 0) result + touchManagedPtr request + return result' + + +-- function webkit_user_media_permission_is_for_audio_device +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "UserMediaPermissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserMediaPermissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_media_permission_is_for_audio_device" webkit_user_media_permission_is_for_audio_device :: + Ptr WebKit2.UserMediaPermissionRequest.UserMediaPermissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "UserMediaPermissionRequest"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 2.8/ +-} +userMediaPermissionIsForAudioDevice :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.UserMediaPermissionRequest.IsUserMediaPermissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.UserMediaPermissionRequest.UserMediaPermissionRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if access to an audio device was requested. -} +userMediaPermissionIsForAudioDevice request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_user_media_permission_is_for_audio_device request' + let result' = (/= 0) result + touchManagedPtr request + return result' + + +-- function webkit_uri_for_display +-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI to be converted", 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_uri_for_display" webkit_uri_for_display :: + CString -> -- uri : TBasicType TUTF8 + IO CString + +{- | +Use this function to format a URI for display. The URIs used internally by +WebKit may contain percent-encoded characters or Punycode, which are not +generally suitable to display to users. This function provides protection +against IDN homograph attacks, so in some cases the host part of the returned +URI may be in Punycode if the safety check fails. + +/Since: 2.24/ +-} +uriForDisplay :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@uri@/: the URI to be converted -} + -> m (Maybe T.Text) + {- ^ __Returns:__ /@uri@/ suitable for display, or 'Nothing' in + case of error. -} +uriForDisplay uri = liftIO $ do + uri' <- textToCString uri + result <- webkit_uri_for_display uri' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + freeMem uri' + return maybeResult + + +-- function webkit_get_minor_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_get_minor_version" webkit_get_minor_version :: + IO Word32 + +{- | +Returns the minor version number of the WebKit library. +(e.g. in WebKit version 1.8.3 this is 8.) + +This function is in the library, so it represents the WebKit library +your code is running against. Contrast with the 'GI.WebKit2.Constants.MINOR_VERSION' +macro, which represents the minor version of the WebKit headers you +have included when compiling your code. +-} +getMinorVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the minor version number of the WebKit library -} +getMinorVersion = liftIO $ do + result <- webkit_get_minor_version + return result + + +-- function webkit_get_micro_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_get_micro_version" webkit_get_micro_version :: + IO Word32 + +{- | +Returns the micro version number of the WebKit library. +(e.g. in WebKit version 1.8.3 this is 3.) + +This function is in the library, so it represents the WebKit library +your code is running against. Contrast with the 'GI.WebKit2.Constants.MICRO_VERSION' +macro, which represents the micro version of the WebKit headers you +have included when compiling your code. +-} +getMicroVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the micro version number of the WebKit library -} +getMicroVersion = liftIO $ do + result <- webkit_get_micro_version + return result + + +-- function webkit_get_major_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_get_major_version" webkit_get_major_version :: + IO Word32 + +{- | +Returns the major version number of the WebKit library. +(e.g. in WebKit version 1.8.3 this is 1.) + +This function is in the library, so it represents the WebKit library +your code is running against. Contrast with the 'GI.WebKit2.Constants.MAJOR_VERSION' +macro, which represents the major version of the WebKit headers you +have included when compiling your code. +-} +getMajorVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ the major version number of the WebKit library -} +getMajorVersion = liftIO $ do + result <- webkit_get_major_version + return result + + + diff --git a/GI/WebKit2/Interfaces.hs b/GI/WebKit2/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Interfaces.hs @@ -0,0 +1,41 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Interfaces + ( module GI.WebKit2.Interfaces.PermissionRequest, + + + ) where + +import GI.WebKit2.Interfaces.PermissionRequest + +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 + + + diff --git a/GI/WebKit2/Interfaces/PermissionRequest.hs b/GI/WebKit2/Interfaces/PermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Interfaces/PermissionRequest.hs @@ -0,0 +1,209 @@ + + +{- | +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.Interfaces.PermissionRequest + ( + +-- * Exported types + PermissionRequest(..) , + noPermissionRequest , + IsPermissionRequest , + toPermissionRequest , + + + -- * Methods +-- ** allow #method:allow# + +#if ENABLE_OVERLOADING + PermissionRequestAllowMethodInfo , +#endif + permissionRequestAllow , + + +-- ** deny #method:deny# + +#if ENABLE_OVERLOADING + PermissionRequestDenyMethodInfo , +#endif + permissionRequestDeny , + + + + + ) 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 + +-- interface PermissionRequest +-- | Memory-managed wrapper type. +newtype PermissionRequest = PermissionRequest (ManagedPtr PermissionRequest) +-- | A convenience alias for `Nothing` :: `Maybe` `PermissionRequest`. +noPermissionRequest :: Maybe PermissionRequest +noPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList PermissionRequest = PermissionRequestSignalList +type PermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +foreign import ccall "webkit_permission_request_get_type" + c_webkit_permission_request_get_type :: IO GType + +instance GObject PermissionRequest where + gobjectType = c_webkit_permission_request_get_type + + +-- | Type class for types which can be safely cast to `PermissionRequest`, for instance with `toPermissionRequest`. +class (GObject o, O.IsDescendantOf PermissionRequest o) => IsPermissionRequest o +instance (GObject o, O.IsDescendantOf PermissionRequest o) => IsPermissionRequest o + +instance O.HasParentTypes PermissionRequest +type instance O.ParentTypes PermissionRequest = '[GObject.Object.Object] + +-- | Cast to `PermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPermissionRequest :: (MonadIO m, IsPermissionRequest o) => o -> m PermissionRequest +toPermissionRequest = liftIO . unsafeCastTo PermissionRequest + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PermissionRequest +type instance O.AttributeList PermissionRequest = PermissionRequestAttributeList +type PermissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolvePermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolvePermissionRequestMethod "allow" o = PermissionRequestAllowMethodInfo + ResolvePermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePermissionRequestMethod "deny" o = PermissionRequestDenyMethodInfo + ResolvePermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePermissionRequestMethod t PermissionRequest, O.MethodInfo info PermissionRequest p) => OL.IsLabel t (PermissionRequest -> 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 + +-- method PermissionRequest::allow +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "PermissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPermissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_permission_request_allow" webkit_permission_request_allow :: + Ptr PermissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "PermissionRequest"}) + IO () + +{- | +Allow the action which triggered this request. +-} +permissionRequestAllow :: + (B.CallStack.HasCallStack, MonadIO m, IsPermissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' -} + -> m () +permissionRequestAllow request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_permission_request_allow request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data PermissionRequestAllowMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPermissionRequest a) => O.MethodInfo PermissionRequestAllowMethodInfo a signature where + overloadedMethod _ = permissionRequestAllow + +#endif + +-- method PermissionRequest::deny +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "PermissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPermissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_permission_request_deny" webkit_permission_request_deny :: + Ptr PermissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "PermissionRequest"}) + IO () + +{- | +Deny the action which triggered this request. +-} +permissionRequestDeny :: + (B.CallStack.HasCallStack, MonadIO m, IsPermissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' -} + -> m () +permissionRequestDeny request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_permission_request_deny request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data PermissionRequestDenyMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPermissionRequest a) => O.MethodInfo PermissionRequestDenyMethodInfo a signature where + overloadedMethod _ = permissionRequestDeny + +#endif + + diff --git a/GI/WebKit2/Interfaces/PermissionRequest.hs-boot b/GI/WebKit2/Interfaces/PermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Interfaces/PermissionRequest.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Interfaces.PermissionRequest 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 + +newtype PermissionRequest = PermissionRequest (ManagedPtr PermissionRequest) +instance GObject PermissionRequest where +class (GObject o, O.IsDescendantOf PermissionRequest o) => IsPermissionRequest o +instance (GObject o, O.IsDescendantOf PermissionRequest o) => IsPermissionRequest o +instance O.HasParentTypes PermissionRequest +#if ENABLE_OVERLOADING +data PermissionRequestAllowMethodInfo +#endif +#if ENABLE_OVERLOADING +data PermissionRequestDenyMethodInfo +#endif diff --git a/GI/WebKit2/Objects.hs b/GI/WebKit2/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects.hs @@ -0,0 +1,123 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Objects + ( module GI.WebKit2.Objects.AuthenticationRequest, + module GI.WebKit2.Objects.AutomationSession, + module GI.WebKit2.Objects.BackForwardList, + module GI.WebKit2.Objects.BackForwardListItem, + module GI.WebKit2.Objects.ColorChooserRequest, + module GI.WebKit2.Objects.ContextMenu , + module GI.WebKit2.Objects.ContextMenuItem, + module GI.WebKit2.Objects.CookieManager , + module GI.WebKit2.Objects.DeviceInfoPermissionRequest, + module GI.WebKit2.Objects.Download , + module GI.WebKit2.Objects.EditorState , + module GI.WebKit2.Objects.FaviconDatabase, + module GI.WebKit2.Objects.FileChooserRequest, + module GI.WebKit2.Objects.FindController, + module GI.WebKit2.Objects.FormSubmissionRequest, + module GI.WebKit2.Objects.GeolocationPermissionRequest, + module GI.WebKit2.Objects.HitTestResult , + module GI.WebKit2.Objects.InstallMissingMediaPluginsPermissionRequest, + module GI.WebKit2.Objects.NavigationPolicyDecision, + module GI.WebKit2.Objects.Notification , + module GI.WebKit2.Objects.NotificationPermissionRequest, + module GI.WebKit2.Objects.OptionMenu , + module GI.WebKit2.Objects.Plugin , + module GI.WebKit2.Objects.PolicyDecision, + module GI.WebKit2.Objects.PrintCustomWidget, + module GI.WebKit2.Objects.PrintOperation, + module GI.WebKit2.Objects.ResponsePolicyDecision, + module GI.WebKit2.Objects.SecurityManager, + module GI.WebKit2.Objects.Settings , + module GI.WebKit2.Objects.URIRequest , + module GI.WebKit2.Objects.URIResponse , + module GI.WebKit2.Objects.URISchemeRequest, + module GI.WebKit2.Objects.UserContentFilterStore, + module GI.WebKit2.Objects.UserContentManager, + module GI.WebKit2.Objects.UserMediaPermissionRequest, + module GI.WebKit2.Objects.WebContext , + module GI.WebKit2.Objects.WebInspector , + module GI.WebKit2.Objects.WebResource , + module GI.WebKit2.Objects.WebView , + module GI.WebKit2.Objects.WebViewBase , + module GI.WebKit2.Objects.WebsiteDataManager, + module GI.WebKit2.Objects.WindowProperties, + + + ) where + +import GI.WebKit2.Objects.AuthenticationRequest +import GI.WebKit2.Objects.AutomationSession +import GI.WebKit2.Objects.BackForwardList +import GI.WebKit2.Objects.BackForwardListItem +import GI.WebKit2.Objects.ColorChooserRequest +import GI.WebKit2.Objects.ContextMenu +import GI.WebKit2.Objects.ContextMenuItem +import GI.WebKit2.Objects.CookieManager +import GI.WebKit2.Objects.DeviceInfoPermissionRequest +import GI.WebKit2.Objects.Download +import GI.WebKit2.Objects.EditorState +import GI.WebKit2.Objects.FaviconDatabase +import GI.WebKit2.Objects.FileChooserRequest +import GI.WebKit2.Objects.FindController +import GI.WebKit2.Objects.FormSubmissionRequest +import GI.WebKit2.Objects.GeolocationPermissionRequest +import GI.WebKit2.Objects.HitTestResult +import GI.WebKit2.Objects.InstallMissingMediaPluginsPermissionRequest +import GI.WebKit2.Objects.NavigationPolicyDecision +import GI.WebKit2.Objects.Notification +import GI.WebKit2.Objects.NotificationPermissionRequest +import GI.WebKit2.Objects.OptionMenu +import GI.WebKit2.Objects.Plugin +import GI.WebKit2.Objects.PolicyDecision +import GI.WebKit2.Objects.PrintCustomWidget +import GI.WebKit2.Objects.PrintOperation +import GI.WebKit2.Objects.ResponsePolicyDecision +import GI.WebKit2.Objects.SecurityManager +import GI.WebKit2.Objects.Settings +import GI.WebKit2.Objects.URIRequest +import GI.WebKit2.Objects.URIResponse +import GI.WebKit2.Objects.URISchemeRequest +import GI.WebKit2.Objects.UserContentFilterStore +import GI.WebKit2.Objects.UserContentManager +import GI.WebKit2.Objects.UserMediaPermissionRequest +import GI.WebKit2.Objects.WebContext +import GI.WebKit2.Objects.WebInspector +import GI.WebKit2.Objects.WebResource +import GI.WebKit2.Objects.WebView +import GI.WebKit2.Objects.WebViewBase +import GI.WebKit2.Objects.WebsiteDataManager +import GI.WebKit2.Objects.WindowProperties + +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 + + + diff --git a/GI/WebKit2/Objects/AuthenticationRequest.hs b/GI/WebKit2/Objects/AuthenticationRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/AuthenticationRequest.hs @@ -0,0 +1,696 @@ + + +{- | +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.AuthenticationRequest + ( + +-- * Exported types + AuthenticationRequest(..) , + IsAuthenticationRequest , + toAuthenticationRequest , + noAuthenticationRequest , + + + -- * Methods +-- ** authenticate #method:authenticate# + +#if ENABLE_OVERLOADING + AuthenticationRequestAuthenticateMethodInfo, +#endif + authenticationRequestAuthenticate , + + +-- ** canSaveCredentials #method:canSaveCredentials# + +#if ENABLE_OVERLOADING + AuthenticationRequestCanSaveCredentialsMethodInfo, +#endif + authenticationRequestCanSaveCredentials , + + +-- ** cancel #method:cancel# + +#if ENABLE_OVERLOADING + AuthenticationRequestCancelMethodInfo , +#endif + authenticationRequestCancel , + + +-- ** getHost #method:getHost# + +#if ENABLE_OVERLOADING + AuthenticationRequestGetHostMethodInfo , +#endif + authenticationRequestGetHost , + + +-- ** getPort #method:getPort# + +#if ENABLE_OVERLOADING + AuthenticationRequestGetPortMethodInfo , +#endif + authenticationRequestGetPort , + + +-- ** getProposedCredential #method:getProposedCredential# + +#if ENABLE_OVERLOADING + AuthenticationRequestGetProposedCredentialMethodInfo, +#endif + authenticationRequestGetProposedCredential, + + +-- ** getRealm #method:getRealm# + +#if ENABLE_OVERLOADING + AuthenticationRequestGetRealmMethodInfo , +#endif + authenticationRequestGetRealm , + + +-- ** getScheme #method:getScheme# + +#if ENABLE_OVERLOADING + AuthenticationRequestGetSchemeMethodInfo, +#endif + authenticationRequestGetScheme , + + +-- ** isForProxy #method:isForProxy# + +#if ENABLE_OVERLOADING + AuthenticationRequestIsForProxyMethodInfo, +#endif + authenticationRequestIsForProxy , + + +-- ** isRetry #method:isRetry# + +#if ENABLE_OVERLOADING + AuthenticationRequestIsRetryMethodInfo , +#endif + authenticationRequestIsRetry , + + + + + -- * Signals +-- ** cancelled #signal:cancelled# + + AuthenticationRequestCancelledCallback , +#if ENABLE_OVERLOADING + AuthenticationRequestCancelledSignalInfo, +#endif + C_AuthenticationRequestCancelledCallback, + afterAuthenticationRequestCancelled , + genClosure_AuthenticationRequestCancelled, + mk_AuthenticationRequestCancelledCallback, + noAuthenticationRequestCancelledCallback, + onAuthenticationRequestCancelled , + wrap_AuthenticationRequestCancelledCallback, + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Structs.Credential as WebKit2.Credential + +-- | Memory-managed wrapper type. +newtype AuthenticationRequest = AuthenticationRequest (ManagedPtr AuthenticationRequest) +foreign import ccall "webkit_authentication_request_get_type" + c_webkit_authentication_request_get_type :: IO GType + +instance GObject AuthenticationRequest where + gobjectType = c_webkit_authentication_request_get_type + + +-- | Type class for types which can be safely cast to `AuthenticationRequest`, for instance with `toAuthenticationRequest`. +class (GObject o, O.IsDescendantOf AuthenticationRequest o) => IsAuthenticationRequest o +instance (GObject o, O.IsDescendantOf AuthenticationRequest o) => IsAuthenticationRequest o + +instance O.HasParentTypes AuthenticationRequest +type instance O.ParentTypes AuthenticationRequest = '[GObject.Object.Object] + +-- | Cast to `AuthenticationRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAuthenticationRequest :: (MonadIO m, IsAuthenticationRequest o) => o -> m AuthenticationRequest +toAuthenticationRequest = liftIO . unsafeCastTo AuthenticationRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `AuthenticationRequest`. +noAuthenticationRequest :: Maybe AuthenticationRequest +noAuthenticationRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAuthenticationRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveAuthenticationRequestMethod "authenticate" o = AuthenticationRequestAuthenticateMethodInfo + ResolveAuthenticationRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAuthenticationRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAuthenticationRequestMethod "canSaveCredentials" o = AuthenticationRequestCanSaveCredentialsMethodInfo + ResolveAuthenticationRequestMethod "cancel" o = AuthenticationRequestCancelMethodInfo + ResolveAuthenticationRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAuthenticationRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAuthenticationRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAuthenticationRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAuthenticationRequestMethod "isForProxy" o = AuthenticationRequestIsForProxyMethodInfo + ResolveAuthenticationRequestMethod "isRetry" o = AuthenticationRequestIsRetryMethodInfo + ResolveAuthenticationRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAuthenticationRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAuthenticationRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAuthenticationRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAuthenticationRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAuthenticationRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAuthenticationRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAuthenticationRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAuthenticationRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAuthenticationRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAuthenticationRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAuthenticationRequestMethod "getHost" o = AuthenticationRequestGetHostMethodInfo + ResolveAuthenticationRequestMethod "getPort" o = AuthenticationRequestGetPortMethodInfo + ResolveAuthenticationRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAuthenticationRequestMethod "getProposedCredential" o = AuthenticationRequestGetProposedCredentialMethodInfo + ResolveAuthenticationRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAuthenticationRequestMethod "getRealm" o = AuthenticationRequestGetRealmMethodInfo + ResolveAuthenticationRequestMethod "getScheme" o = AuthenticationRequestGetSchemeMethodInfo + ResolveAuthenticationRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAuthenticationRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAuthenticationRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAuthenticationRequestMethod t AuthenticationRequest, O.MethodInfo info AuthenticationRequest p) => OL.IsLabel t (AuthenticationRequest -> 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 AuthenticationRequest::cancelled +{- | +This signal is emitted when the user authentication request is +cancelled. It allows the application to dismiss its authentication +dialog in case of page load failure for example. + +/Since: 2.2/ +-} +type AuthenticationRequestCancelledCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthenticationRequestCancelledCallback`@. +noAuthenticationRequestCancelledCallback :: Maybe AuthenticationRequestCancelledCallback +noAuthenticationRequestCancelledCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_AuthenticationRequestCancelledCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_AuthenticationRequestCancelledCallback`. +foreign import ccall "wrapper" + mk_AuthenticationRequestCancelledCallback :: C_AuthenticationRequestCancelledCallback -> IO (FunPtr C_AuthenticationRequestCancelledCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_AuthenticationRequestCancelled :: MonadIO m => AuthenticationRequestCancelledCallback -> m (GClosure C_AuthenticationRequestCancelledCallback) +genClosure_AuthenticationRequestCancelled cb = liftIO $ do + let cb' = wrap_AuthenticationRequestCancelledCallback cb + mk_AuthenticationRequestCancelledCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `AuthenticationRequestCancelledCallback` into a `C_AuthenticationRequestCancelledCallback`. +wrap_AuthenticationRequestCancelledCallback :: + AuthenticationRequestCancelledCallback -> + C_AuthenticationRequestCancelledCallback +wrap_AuthenticationRequestCancelledCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@cancelled@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' authenticationRequest #cancelled callback +@ +-} +onAuthenticationRequestCancelled :: (IsAuthenticationRequest a, MonadIO m) => a -> AuthenticationRequestCancelledCallback -> m SignalHandlerId +onAuthenticationRequestCancelled obj cb = liftIO $ do + let cb' = wrap_AuthenticationRequestCancelledCallback cb + cb'' <- mk_AuthenticationRequestCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@cancelled@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' authenticationRequest #cancelled callback +@ +-} +afterAuthenticationRequestCancelled :: (IsAuthenticationRequest a, MonadIO m) => a -> AuthenticationRequestCancelledCallback -> m SignalHandlerId +afterAuthenticationRequestCancelled obj cb = liftIO $ do + let cb' = wrap_AuthenticationRequestCancelledCallback cb + cb'' <- mk_AuthenticationRequestCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AuthenticationRequest +type instance O.AttributeList AuthenticationRequest = AuthenticationRequestAttributeList +type AuthenticationRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data AuthenticationRequestCancelledSignalInfo +instance SignalInfo AuthenticationRequestCancelledSignalInfo where + type HaskellCallbackType AuthenticationRequestCancelledSignalInfo = AuthenticationRequestCancelledCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_AuthenticationRequestCancelledCallback cb + cb'' <- mk_AuthenticationRequestCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' connectMode + +type instance O.SignalList AuthenticationRequest = AuthenticationRequestSignalList +type AuthenticationRequestSignalList = ('[ '("cancelled", AuthenticationRequestCancelledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AuthenticationRequest::authenticate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #WebKitCredential, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_authenticate" webkit_authentication_request_authenticate :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + Ptr WebKit2.Credential.Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO () + +{- | +Authenticate the 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' using the 'GI.WebKit2.Structs.Credential.Credential' +supplied. To continue without credentials, pass 'Nothing' as /@credential@/. + +/Since: 2.2/ +-} +authenticationRequestAuthenticate :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> Maybe (WebKit2.Credential.Credential) + {- ^ /@credential@/: A 'GI.WebKit2.Structs.Credential.Credential', or 'Nothing' -} + -> m () +authenticationRequestAuthenticate request credential = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + maybeCredential <- case credential of + Nothing -> return nullPtr + Just jCredential -> do + jCredential' <- unsafeManagedPtrGetPtr jCredential + return jCredential' + webkit_authentication_request_authenticate request' maybeCredential + touchManagedPtr request + whenJust credential touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data AuthenticationRequestAuthenticateMethodInfo +instance (signature ~ (Maybe (WebKit2.Credential.Credential) -> m ()), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestAuthenticateMethodInfo a signature where + overloadedMethod _ = authenticationRequestAuthenticate + +#endif + +-- method AuthenticationRequest::can_save_credentials +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_can_save_credentials" webkit_authentication_request_can_save_credentials :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CInt + +{- | +Determine whether the authentication method associated with this +'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' should allow the storage of credentials. +This will return 'False' if WebKit doesn\'t support credential storing +or if private browsing is enabled. + +/Since: 2.2/ +-} +authenticationRequestCanSaveCredentials :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if WebKit can store credentials or 'False' otherwise. -} +authenticationRequestCanSaveCredentials request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_can_save_credentials request' + let result' = (/= 0) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestCanSaveCredentialsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestCanSaveCredentialsMethodInfo a signature where + overloadedMethod _ = authenticationRequestCanSaveCredentials + +#endif + +-- method AuthenticationRequest::cancel +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_cancel" webkit_authentication_request_cancel :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO () + +{- | +Cancel the authentication challenge. This will also cancel the page loading and result in a +'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal with a 'GI.WebKit2.Enums.NetworkError' of type 'GI.WebKit2.Enums.NetworkErrorCancelled' being emitted. + +/Since: 2.2/ +-} +authenticationRequestCancel :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m () +authenticationRequestCancel request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_authentication_request_cancel request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data AuthenticationRequestCancelMethodInfo +instance (signature ~ (m ()), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestCancelMethodInfo a signature where + overloadedMethod _ = authenticationRequestCancel + +#endif + +-- method AuthenticationRequest::get_host +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", 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_authentication_request_get_host" webkit_authentication_request_get_host :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CString + +{- | +Get the host that this authentication challenge is applicable to. + +/Since: 2.2/ +-} +authenticationRequestGetHost :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m T.Text + {- ^ __Returns:__ The host of /@request@/. -} +authenticationRequestGetHost request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_get_host request' + checkUnexpectedReturnNULL "authenticationRequestGetHost" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestGetHostMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestGetHostMethodInfo a signature where + overloadedMethod _ = authenticationRequestGetHost + +#endif + +-- method AuthenticationRequest::get_port +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_get_port" webkit_authentication_request_get_port :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO Word32 + +{- | +Get the port that this authentication challenge is applicable to. + +/Since: 2.2/ +-} +authenticationRequestGetPort :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m Word32 + {- ^ __Returns:__ The port of /@request@/. -} +authenticationRequestGetPort request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_get_port request' + touchManagedPtr request + return result + +#if ENABLE_OVERLOADING +data AuthenticationRequestGetPortMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestGetPortMethodInfo a signature where + overloadedMethod _ = authenticationRequestGetPort + +#endif + +-- method AuthenticationRequest::get_proposed_credential +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Credential"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_get_proposed_credential" webkit_authentication_request_get_proposed_credential :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO (Ptr WebKit2.Credential.Credential) + +{- | +Get the 'GI.WebKit2.Structs.Credential.Credential' of the proposed authentication challenge that was +stored from a previous session. The client can use this directly for +authentication or construct their own 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +authenticationRequestGetProposedCredential :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m WebKit2.Credential.Credential + {- ^ __Returns:__ A 'GI.WebKit2.Structs.Credential.Credential' encapsulating credential details +or 'Nothing' if there is no stored credential. -} +authenticationRequestGetProposedCredential request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_get_proposed_credential request' + checkUnexpectedReturnNULL "authenticationRequestGetProposedCredential" result + result' <- (wrapBoxed WebKit2.Credential.Credential) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestGetProposedCredentialMethodInfo +instance (signature ~ (m WebKit2.Credential.Credential), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestGetProposedCredentialMethodInfo a signature where + overloadedMethod _ = authenticationRequestGetProposedCredential + +#endif + +-- method AuthenticationRequest::get_realm +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", 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_authentication_request_get_realm" webkit_authentication_request_get_realm :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CString + +{- | +Get the realm that this authentication challenge is applicable to. + +/Since: 2.2/ +-} +authenticationRequestGetRealm :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m T.Text + {- ^ __Returns:__ The realm of /@request@/. -} +authenticationRequestGetRealm request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_get_realm request' + checkUnexpectedReturnNULL "authenticationRequestGetRealm" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestGetRealmMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestGetRealmMethodInfo a signature where + overloadedMethod _ = authenticationRequestGetRealm + +#endif + +-- method AuthenticationRequest::get_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "AuthenticationScheme"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_get_scheme" webkit_authentication_request_get_scheme :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CUInt + +{- | +Get the authentication scheme of the authentication challenge. + +/Since: 2.2/ +-} +authenticationRequestGetScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m WebKit2.Enums.AuthenticationScheme + {- ^ __Returns:__ The 'GI.WebKit2.Enums.AuthenticationScheme' of /@request@/. -} +authenticationRequestGetScheme request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_get_scheme request' + let result' = (toEnum . fromIntegral) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestGetSchemeMethodInfo +instance (signature ~ (m WebKit2.Enums.AuthenticationScheme), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestGetSchemeMethodInfo a signature where + overloadedMethod _ = authenticationRequestGetScheme + +#endif + +-- method AuthenticationRequest::is_for_proxy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_is_for_proxy" webkit_authentication_request_is_for_proxy :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CInt + +{- | +Determine whether the authentication challenge is associated with a proxy server rather than an \"origin\" server. + +/Since: 2.2/ +-} +authenticationRequestIsForProxy :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if authentication is for a proxy or 'False' otherwise. -} +authenticationRequestIsForProxy request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_is_for_proxy request' + let result' = (/= 0) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestIsForProxyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestIsForProxyMethodInfo a signature where + overloadedMethod _ = authenticationRequestIsForProxy + +#endif + +-- method AuthenticationRequest::is_retry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAuthenticationRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_authentication_request_is_retry" webkit_authentication_request_is_retry :: + Ptr AuthenticationRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "AuthenticationRequest"}) + IO CInt + +{- | +Determine whether this this is a first attempt or a retry for this authentication challenge. + +/Since: 2.2/ +-} +authenticationRequestIsRetry :: + (B.CallStack.HasCallStack, MonadIO m, IsAuthenticationRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if authentication attempt is a retry or 'False' otherwise. -} +authenticationRequestIsRetry request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_authentication_request_is_retry request' + let result' = (/= 0) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data AuthenticationRequestIsRetryMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAuthenticationRequest a) => O.MethodInfo AuthenticationRequestIsRetryMethodInfo a signature where + overloadedMethod _ = authenticationRequestIsRetry + +#endif + + diff --git a/GI/WebKit2/Objects/AuthenticationRequest.hs-boot b/GI/WebKit2/Objects/AuthenticationRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/AuthenticationRequest.hs-boot @@ -0,0 +1,62 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.AuthenticationRequest 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 + +newtype AuthenticationRequest = AuthenticationRequest (ManagedPtr AuthenticationRequest) +instance GObject AuthenticationRequest where +class (GObject o, O.IsDescendantOf AuthenticationRequest o) => IsAuthenticationRequest o +instance (GObject o, O.IsDescendantOf AuthenticationRequest o) => IsAuthenticationRequest o +instance O.HasParentTypes AuthenticationRequest +#if ENABLE_OVERLOADING +data AuthenticationRequestCancelledSignalInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestAuthenticateMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestCanSaveCredentialsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestCancelMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestGetHostMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestGetPortMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestGetProposedCredentialMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestGetRealmMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestGetSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestIsForProxyMethodInfo +#endif +#if ENABLE_OVERLOADING +data AuthenticationRequestIsRetryMethodInfo +#endif diff --git a/GI/WebKit2/Objects/AutomationSession.hs b/GI/WebKit2/Objects/AutomationSession.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/AutomationSession.hs @@ -0,0 +1,433 @@ + + +{- | +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.AutomationSession + ( + +-- * Exported types + AutomationSession(..) , + IsAutomationSession , + toAutomationSession , + noAutomationSession , + + + -- * Methods +-- ** getApplicationInfo #method:getApplicationInfo# + +#if ENABLE_OVERLOADING + AutomationSessionGetApplicationInfoMethodInfo, +#endif + automationSessionGetApplicationInfo , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + AutomationSessionGetIdMethodInfo , +#endif + automationSessionGetId , + + +-- ** setApplicationInfo #method:setApplicationInfo# + +#if ENABLE_OVERLOADING + AutomationSessionSetApplicationInfoMethodInfo, +#endif + automationSessionSetApplicationInfo , + + + + + -- * Properties +-- ** id #attr:id# +{- | The session unique identifier. + +/Since: 2.18/ +-} +#if ENABLE_OVERLOADING + AutomationSessionIdPropertyInfo , +#endif +#if ENABLE_OVERLOADING + automationSessionId , +#endif + constructAutomationSessionId , + getAutomationSessionId , + + + + + -- * Signals +-- ** createWebView #signal:createWebView# + + AutomationSessionCreateWebViewCallback , +#if ENABLE_OVERLOADING + AutomationSessionCreateWebViewSignalInfo, +#endif + C_AutomationSessionCreateWebViewCallback, + afterAutomationSessionCreateWebView , + genClosure_AutomationSessionCreateWebView, + mk_AutomationSessionCreateWebViewCallback, + noAutomationSessionCreateWebViewCallback, + onAutomationSessionCreateWebView , + wrap_AutomationSessionCreateWebViewCallback, + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView +import {-# SOURCE #-} qualified GI.WebKit2.Structs.ApplicationInfo as WebKit2.ApplicationInfo + +-- | Memory-managed wrapper type. +newtype AutomationSession = AutomationSession (ManagedPtr AutomationSession) +foreign import ccall "webkit_automation_session_get_type" + c_webkit_automation_session_get_type :: IO GType + +instance GObject AutomationSession where + gobjectType = c_webkit_automation_session_get_type + + +-- | Type class for types which can be safely cast to `AutomationSession`, for instance with `toAutomationSession`. +class (GObject o, O.IsDescendantOf AutomationSession o) => IsAutomationSession o +instance (GObject o, O.IsDescendantOf AutomationSession o) => IsAutomationSession o + +instance O.HasParentTypes AutomationSession +type instance O.ParentTypes AutomationSession = '[GObject.Object.Object] + +-- | Cast to `AutomationSession`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAutomationSession :: (MonadIO m, IsAutomationSession o) => o -> m AutomationSession +toAutomationSession = liftIO . unsafeCastTo AutomationSession + +-- | A convenience alias for `Nothing` :: `Maybe` `AutomationSession`. +noAutomationSession :: Maybe AutomationSession +noAutomationSession = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAutomationSessionMethod (t :: Symbol) (o :: *) :: * where + ResolveAutomationSessionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAutomationSessionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAutomationSessionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAutomationSessionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAutomationSessionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAutomationSessionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAutomationSessionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAutomationSessionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAutomationSessionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAutomationSessionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAutomationSessionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAutomationSessionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAutomationSessionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAutomationSessionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAutomationSessionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAutomationSessionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAutomationSessionMethod "getApplicationInfo" o = AutomationSessionGetApplicationInfoMethodInfo + ResolveAutomationSessionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAutomationSessionMethod "getId" o = AutomationSessionGetIdMethodInfo + ResolveAutomationSessionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAutomationSessionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAutomationSessionMethod "setApplicationInfo" o = AutomationSessionSetApplicationInfoMethodInfo + ResolveAutomationSessionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAutomationSessionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAutomationSessionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAutomationSessionMethod t AutomationSession, O.MethodInfo info AutomationSession p) => OL.IsLabel t (AutomationSession -> 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 AutomationSession::create-web-view +{- | +This signal is emitted when the automation client requests a new +browsing context to interact with it. The callback handler should +return a 'GI.WebKit2.Objects.WebView.WebView' created with 'GI.WebKit2.Objects.WebView.WebView':@/is-controlled-by-automation/@ +construct property enabled. The returned 'GI.WebKit2.Objects.WebView.WebView' could be an existing +web view or a new one created and added to a new tab or window. + +/Since: 2.18/ +-} +type AutomationSessionCreateWebViewCallback = + IO WebKit2.WebView.WebView + {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebView.WebView' widget. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `AutomationSessionCreateWebViewCallback`@. +noAutomationSessionCreateWebViewCallback :: Maybe AutomationSessionCreateWebViewCallback +noAutomationSessionCreateWebViewCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_AutomationSessionCreateWebViewCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO (Ptr WebKit2.WebView.WebView) + +-- | Generate a function pointer callable from C code, from a `C_AutomationSessionCreateWebViewCallback`. +foreign import ccall "wrapper" + mk_AutomationSessionCreateWebViewCallback :: C_AutomationSessionCreateWebViewCallback -> IO (FunPtr C_AutomationSessionCreateWebViewCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_AutomationSessionCreateWebView :: MonadIO m => AutomationSessionCreateWebViewCallback -> m (GClosure C_AutomationSessionCreateWebViewCallback) +genClosure_AutomationSessionCreateWebView cb = liftIO $ do + let cb' = wrap_AutomationSessionCreateWebViewCallback cb + mk_AutomationSessionCreateWebViewCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `AutomationSessionCreateWebViewCallback` into a `C_AutomationSessionCreateWebViewCallback`. +wrap_AutomationSessionCreateWebViewCallback :: + AutomationSessionCreateWebViewCallback -> + C_AutomationSessionCreateWebViewCallback +wrap_AutomationSessionCreateWebViewCallback _cb _ _ = do + result <- _cb + result' <- unsafeManagedPtrCastPtr result + return result' + + +{- | +Connect a signal handler for the “@create-web-view@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' automationSession #createWebView callback +@ +-} +onAutomationSessionCreateWebView :: (IsAutomationSession a, MonadIO m) => a -> AutomationSessionCreateWebViewCallback -> m SignalHandlerId +onAutomationSessionCreateWebView obj cb = liftIO $ do + let cb' = wrap_AutomationSessionCreateWebViewCallback cb + cb'' <- mk_AutomationSessionCreateWebViewCallback cb' + connectSignalFunPtr obj "create-web-view" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@create-web-view@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' automationSession #createWebView callback +@ +-} +afterAutomationSessionCreateWebView :: (IsAutomationSession a, MonadIO m) => a -> AutomationSessionCreateWebViewCallback -> m SignalHandlerId +afterAutomationSessionCreateWebView obj cb = liftIO $ do + let cb' = wrap_AutomationSessionCreateWebViewCallback cb + cb'' <- mk_AutomationSessionCreateWebViewCallback cb' + connectSignalFunPtr obj "create-web-view" cb'' SignalConnectAfter + + +-- VVV Prop "id" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' automationSession #id +@ +-} +getAutomationSessionId :: (MonadIO m, IsAutomationSession o) => o -> m T.Text +getAutomationSessionId obj = liftIO $ checkUnexpectedNothing "getAutomationSessionId" $ B.Properties.getObjectPropertyString obj "id" + +{- | +Construct a `GValueConstruct` with valid value for the “@id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructAutomationSessionId :: (IsAutomationSession o) => T.Text -> IO (GValueConstruct o) +constructAutomationSessionId val = B.Properties.constructObjectPropertyString "id" (Just val) + +#if ENABLE_OVERLOADING +data AutomationSessionIdPropertyInfo +instance AttrInfo AutomationSessionIdPropertyInfo where + type AttrAllowedOps AutomationSessionIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint AutomationSessionIdPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint AutomationSessionIdPropertyInfo = IsAutomationSession + type AttrGetType AutomationSessionIdPropertyInfo = T.Text + type AttrLabel AutomationSessionIdPropertyInfo = "id" + type AttrOrigin AutomationSessionIdPropertyInfo = AutomationSession + attrGet _ = getAutomationSessionId + attrSet _ = undefined + attrConstruct _ = constructAutomationSessionId + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AutomationSession +type instance O.AttributeList AutomationSession = AutomationSessionAttributeList +type AutomationSessionAttributeList = ('[ '("id", AutomationSessionIdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +automationSessionId :: AttrLabelProxy "id" +automationSessionId = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data AutomationSessionCreateWebViewSignalInfo +instance SignalInfo AutomationSessionCreateWebViewSignalInfo where + type HaskellCallbackType AutomationSessionCreateWebViewSignalInfo = AutomationSessionCreateWebViewCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_AutomationSessionCreateWebViewCallback cb + cb'' <- mk_AutomationSessionCreateWebViewCallback cb' + connectSignalFunPtr obj "create-web-view" cb'' connectMode + +type instance O.SignalList AutomationSession = AutomationSessionSignalList +type AutomationSessionSignalList = ('[ '("createWebView", AutomationSessionCreateWebViewSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AutomationSession::get_application_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "session", argType = TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAutomationSession", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_automation_session_get_application_info" webkit_automation_session_get_application_info :: + Ptr AutomationSession -> -- session : TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}) + IO (Ptr WebKit2.ApplicationInfo.ApplicationInfo) + +{- | +Get the 'GI.WebKit2.Objects.AutomationSession.AutomationSession' previously set with 'GI.WebKit2.Objects.AutomationSession.automationSessionSetApplicationInfo'. + +/Since: 2.18/ +-} +automationSessionGetApplicationInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsAutomationSession a) => + a + {- ^ /@session@/: a 'GI.WebKit2.Objects.AutomationSession.AutomationSession' -} + -> m (Maybe WebKit2.ApplicationInfo.ApplicationInfo) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.AutomationSession.AutomationSession' of /@session@/, or 'Nothing' if no one has been set. -} +automationSessionGetApplicationInfo session = liftIO $ do + session' <- unsafeManagedPtrCastPtr session + result <- webkit_automation_session_get_application_info session' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed WebKit2.ApplicationInfo.ApplicationInfo) result' + return result'' + touchManagedPtr session + return maybeResult + +#if ENABLE_OVERLOADING +data AutomationSessionGetApplicationInfoMethodInfo +instance (signature ~ (m (Maybe WebKit2.ApplicationInfo.ApplicationInfo)), MonadIO m, IsAutomationSession a) => O.MethodInfo AutomationSessionGetApplicationInfoMethodInfo a signature where + overloadedMethod _ = automationSessionGetApplicationInfo + +#endif + +-- method AutomationSession::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "session", argType = TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAutomationSession", 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_automation_session_get_id" webkit_automation_session_get_id :: + Ptr AutomationSession -> -- session : TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}) + IO CString + +{- | +Get the unique identifier of a 'GI.WebKit2.Objects.AutomationSession.AutomationSession' + +/Since: 2.18/ +-} +automationSessionGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsAutomationSession a) => + a + {- ^ /@session@/: a 'GI.WebKit2.Objects.AutomationSession.AutomationSession' -} + -> m T.Text + {- ^ __Returns:__ the unique identifier of /@session@/ -} +automationSessionGetId session = liftIO $ do + session' <- unsafeManagedPtrCastPtr session + result <- webkit_automation_session_get_id session' + checkUnexpectedReturnNULL "automationSessionGetId" result + result' <- cstringToText result + touchManagedPtr session + return result' + +#if ENABLE_OVERLOADING +data AutomationSessionGetIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAutomationSession a) => O.MethodInfo AutomationSessionGetIdMethodInfo a signature where + overloadedMethod _ = automationSessionGetId + +#endif + +-- method AutomationSession::set_application_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "session", argType = TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitAutomationSession", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_automation_session_set_application_info" webkit_automation_session_set_application_info :: + Ptr AutomationSession -> -- session : TInterface (Name {namespace = "WebKit2", name = "AutomationSession"}) + Ptr WebKit2.ApplicationInfo.ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + IO () + +{- | +Set the application information to /@session@/. This information will be used by the driver service +to match the requested capabilities with the actual application information. If this information +is not provided to the session when a new automation session is requested, the creation might fail +if the client requested a specific browser name or version. This will not have any effect when called +after the automation session has been fully created, so this must be called in the callback of +'GI.WebKit2.Objects.WebContext.WebContext'::@/automation-started/@ signal. + +/Since: 2.18/ +-} +automationSessionSetApplicationInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsAutomationSession a) => + a + {- ^ /@session@/: a 'GI.WebKit2.Objects.AutomationSession.AutomationSession' -} + -> WebKit2.ApplicationInfo.ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> m () +automationSessionSetApplicationInfo session info = liftIO $ do + session' <- unsafeManagedPtrCastPtr session + info' <- unsafeManagedPtrGetPtr info + webkit_automation_session_set_application_info session' info' + touchManagedPtr session + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data AutomationSessionSetApplicationInfoMethodInfo +instance (signature ~ (WebKit2.ApplicationInfo.ApplicationInfo -> m ()), MonadIO m, IsAutomationSession a) => O.MethodInfo AutomationSessionSetApplicationInfoMethodInfo a signature where + overloadedMethod _ = automationSessionSetApplicationInfo + +#endif + + diff --git a/GI/WebKit2/Objects/AutomationSession.hs-boot b/GI/WebKit2/Objects/AutomationSession.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/AutomationSession.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.AutomationSession 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 + +newtype AutomationSession = AutomationSession (ManagedPtr AutomationSession) +instance GObject AutomationSession where +class (GObject o, O.IsDescendantOf AutomationSession o) => IsAutomationSession o +instance (GObject o, O.IsDescendantOf AutomationSession o) => IsAutomationSession o +instance O.HasParentTypes AutomationSession +#if ENABLE_OVERLOADING +data AutomationSessionIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data AutomationSessionCreateWebViewSignalInfo +#endif +#if ENABLE_OVERLOADING +data AutomationSessionGetApplicationInfoMethodInfo +#endif +#if ENABLE_OVERLOADING +data AutomationSessionGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data AutomationSessionSetApplicationInfoMethodInfo +#endif diff --git a/GI/WebKit2/Objects/BackForwardList.hs b/GI/WebKit2/Objects/BackForwardList.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/BackForwardList.hs @@ -0,0 +1,660 @@ + + +{- | +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.BackForwardList + ( + +-- * Exported types + BackForwardList(..) , + IsBackForwardList , + toBackForwardList , + noBackForwardList , + + + -- * Methods +-- ** getBackItem #method:getBackItem# + +#if ENABLE_OVERLOADING + BackForwardListGetBackItemMethodInfo , +#endif + backForwardListGetBackItem , + + +-- ** getBackList #method:getBackList# + +#if ENABLE_OVERLOADING + BackForwardListGetBackListMethodInfo , +#endif + backForwardListGetBackList , + + +-- ** getBackListWithLimit #method:getBackListWithLimit# + +#if ENABLE_OVERLOADING + BackForwardListGetBackListWithLimitMethodInfo, +#endif + backForwardListGetBackListWithLimit , + + +-- ** getCurrentItem #method:getCurrentItem# + +#if ENABLE_OVERLOADING + BackForwardListGetCurrentItemMethodInfo , +#endif + backForwardListGetCurrentItem , + + +-- ** getForwardItem #method:getForwardItem# + +#if ENABLE_OVERLOADING + BackForwardListGetForwardItemMethodInfo , +#endif + backForwardListGetForwardItem , + + +-- ** getForwardList #method:getForwardList# + +#if ENABLE_OVERLOADING + BackForwardListGetForwardListMethodInfo , +#endif + backForwardListGetForwardList , + + +-- ** getForwardListWithLimit #method:getForwardListWithLimit# + +#if ENABLE_OVERLOADING + BackForwardListGetForwardListWithLimitMethodInfo, +#endif + backForwardListGetForwardListWithLimit , + + +-- ** getLength #method:getLength# + +#if ENABLE_OVERLOADING + BackForwardListGetLengthMethodInfo , +#endif + backForwardListGetLength , + + +-- ** getNthItem #method:getNthItem# + +#if ENABLE_OVERLOADING + BackForwardListGetNthItemMethodInfo , +#endif + backForwardListGetNthItem , + + + + + -- * Signals +-- ** changed #signal:changed# + + BackForwardListChangedCallback , +#if ENABLE_OVERLOADING + BackForwardListChangedSignalInfo , +#endif + C_BackForwardListChangedCallback , + afterBackForwardListChanged , + genClosure_BackForwardListChanged , + mk_BackForwardListChangedCallback , + noBackForwardListChangedCallback , + onBackForwardListChanged , + wrap_BackForwardListChangedCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardListItem as WebKit2.BackForwardListItem + +-- | Memory-managed wrapper type. +newtype BackForwardList = BackForwardList (ManagedPtr BackForwardList) +foreign import ccall "webkit_back_forward_list_get_type" + c_webkit_back_forward_list_get_type :: IO GType + +instance GObject BackForwardList where + gobjectType = c_webkit_back_forward_list_get_type + + +-- | Type class for types which can be safely cast to `BackForwardList`, for instance with `toBackForwardList`. +class (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o +instance (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o + +instance O.HasParentTypes BackForwardList +type instance O.ParentTypes BackForwardList = '[GObject.Object.Object] + +-- | Cast to `BackForwardList`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBackForwardList :: (MonadIO m, IsBackForwardList o) => o -> m BackForwardList +toBackForwardList = liftIO . unsafeCastTo BackForwardList + +-- | A convenience alias for `Nothing` :: `Maybe` `BackForwardList`. +noBackForwardList :: Maybe BackForwardList +noBackForwardList = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBackForwardListMethod (t :: Symbol) (o :: *) :: * where + ResolveBackForwardListMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBackForwardListMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBackForwardListMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBackForwardListMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBackForwardListMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBackForwardListMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBackForwardListMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBackForwardListMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBackForwardListMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBackForwardListMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBackForwardListMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBackForwardListMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBackForwardListMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBackForwardListMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBackForwardListMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBackForwardListMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBackForwardListMethod "getBackItem" o = BackForwardListGetBackItemMethodInfo + ResolveBackForwardListMethod "getBackList" o = BackForwardListGetBackListMethodInfo + ResolveBackForwardListMethod "getBackListWithLimit" o = BackForwardListGetBackListWithLimitMethodInfo + ResolveBackForwardListMethod "getCurrentItem" o = BackForwardListGetCurrentItemMethodInfo + ResolveBackForwardListMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBackForwardListMethod "getForwardItem" o = BackForwardListGetForwardItemMethodInfo + ResolveBackForwardListMethod "getForwardList" o = BackForwardListGetForwardListMethodInfo + ResolveBackForwardListMethod "getForwardListWithLimit" o = BackForwardListGetForwardListWithLimitMethodInfo + ResolveBackForwardListMethod "getLength" o = BackForwardListGetLengthMethodInfo + ResolveBackForwardListMethod "getNthItem" o = BackForwardListGetNthItemMethodInfo + ResolveBackForwardListMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBackForwardListMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBackForwardListMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBackForwardListMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBackForwardListMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBackForwardListMethod t BackForwardList, O.MethodInfo info BackForwardList p) => OL.IsLabel t (BackForwardList -> 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 BackForwardList::changed +{- | +This signal is emitted when /@backForwardList@/ changes. This happens +when the current item is updated, a new item is added or one or more +items are removed. Note that both /@itemAdded@/ and /@itemsRemoved@/ can +'Nothing' when only the current item is updated. Items are only removed +when the list is cleared or the maximum items limit is reached. +-} +type BackForwardListChangedCallback = + Maybe WebKit2.BackForwardListItem.BackForwardListItem + {- ^ /@itemAdded@/: the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' added or 'Nothing' -} + -> Ptr () + {- ^ /@itemsRemoved@/: a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'\s -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BackForwardListChangedCallback`@. +noBackForwardListChangedCallback :: Maybe BackForwardListChangedCallback +noBackForwardListChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_BackForwardListChangedCallback = + Ptr () -> -- object + Ptr WebKit2.BackForwardListItem.BackForwardListItem -> + Ptr () -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_BackForwardListChangedCallback`. +foreign import ccall "wrapper" + mk_BackForwardListChangedCallback :: C_BackForwardListChangedCallback -> IO (FunPtr C_BackForwardListChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_BackForwardListChanged :: MonadIO m => BackForwardListChangedCallback -> m (GClosure C_BackForwardListChangedCallback) +genClosure_BackForwardListChanged cb = liftIO $ do + let cb' = wrap_BackForwardListChangedCallback cb + mk_BackForwardListChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BackForwardListChangedCallback` into a `C_BackForwardListChangedCallback`. +wrap_BackForwardListChangedCallback :: + BackForwardListChangedCallback -> + C_BackForwardListChangedCallback +wrap_BackForwardListChangedCallback _cb _ itemAdded itemsRemoved _ = do + maybeItemAdded <- + if itemAdded == nullPtr + then return Nothing + else do + itemAdded' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) itemAdded + return $ Just itemAdded' + _cb maybeItemAdded itemsRemoved + + +{- | +Connect a signal handler for the “@changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' backForwardList #changed callback +@ +-} +onBackForwardListChanged :: (IsBackForwardList a, MonadIO m) => a -> BackForwardListChangedCallback -> m SignalHandlerId +onBackForwardListChanged obj cb = liftIO $ do + let cb' = wrap_BackForwardListChangedCallback cb + cb'' <- mk_BackForwardListChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' backForwardList #changed callback +@ +-} +afterBackForwardListChanged :: (IsBackForwardList a, MonadIO m) => a -> BackForwardListChangedCallback -> m SignalHandlerId +afterBackForwardListChanged obj cb = liftIO $ do + let cb' = wrap_BackForwardListChangedCallback cb + cb'' <- mk_BackForwardListChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BackForwardList +type instance O.AttributeList BackForwardList = BackForwardListAttributeList +type BackForwardListAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data BackForwardListChangedSignalInfo +instance SignalInfo BackForwardListChangedSignalInfo where + type HaskellCallbackType BackForwardListChangedSignalInfo = BackForwardListChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BackForwardListChangedCallback cb + cb'' <- mk_BackForwardListChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' connectMode + +type instance O.SignalList BackForwardList = BackForwardListSignalList +type BackForwardListSignalList = ('[ '("changed", BackForwardListChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method BackForwardList::get_back_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_back_item" webkit_back_forward_list_get_back_item :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem) + +{- | +Returns the item that precedes the current item. +-} +backForwardListGetBackItem :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' + preceding the current item or 'Nothing'. -} +backForwardListGetBackItem backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_back_item backForwardList' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + return result'' + touchManagedPtr backForwardList + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListGetBackItemMethodInfo +instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackItemMethodInfo a signature where + overloadedMethod _ = backForwardListGetBackItem + +#endif + +-- method BackForwardList::get_back_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_back_list" webkit_back_forward_list_get_back_list :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem))) + +{- | +/No description available in the introspection data./ +-} +backForwardListGetBackList :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m [WebKit2.BackForwardListItem.BackForwardListItem] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of + items preceding the current item. -} +backForwardListGetBackList backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_back_list backForwardList' + result' <- unpackGList result + result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + g_list_free result + touchManagedPtr backForwardList + return result'' + +#if ENABLE_OVERLOADING +data BackForwardListGetBackListMethodInfo +instance (signature ~ (m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackListMethodInfo a signature where + overloadedMethod _ = backForwardListGetBackList + +#endif + +-- method BackForwardList::get_back_list_with_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to retrieve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_back_list_with_limit" webkit_back_forward_list_get_back_list_with_limit :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + Word32 -> -- limit : TBasicType TUInt + IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem))) + +{- | +/No description available in the introspection data./ +-} +backForwardListGetBackListWithLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> Word32 + {- ^ /@limit@/: the number of items to retrieve -} + -> m [WebKit2.BackForwardListItem.BackForwardListItem] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of + items preceding the current item limited by /@limit@/. -} +backForwardListGetBackListWithLimit backForwardList limit = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_back_list_with_limit backForwardList' limit + result' <- unpackGList result + result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + g_list_free result + touchManagedPtr backForwardList + return result'' + +#if ENABLE_OVERLOADING +data BackForwardListGetBackListWithLimitMethodInfo +instance (signature ~ (Word32 -> m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackListWithLimitMethodInfo a signature where + overloadedMethod _ = backForwardListGetBackListWithLimit + +#endif + +-- method BackForwardList::get_current_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_current_item" webkit_back_forward_list_get_current_item :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem) + +{- | +Returns the current item in /@backForwardList@/. +-} +backForwardListGetCurrentItem :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem) + {- ^ __Returns:__ a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' + or 'Nothing' if /@backForwardList@/ is empty. -} +backForwardListGetCurrentItem backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_current_item backForwardList' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + return result'' + touchManagedPtr backForwardList + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListGetCurrentItemMethodInfo +instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetCurrentItemMethodInfo a signature where + overloadedMethod _ = backForwardListGetCurrentItem + +#endif + +-- method BackForwardList::get_forward_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_forward_item" webkit_back_forward_list_get_forward_item :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem) + +{- | +Returns the item that follows the current item. +-} +backForwardListGetForwardItem :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' + following the current item or 'Nothing'. -} +backForwardListGetForwardItem backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_forward_item backForwardList' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + return result'' + touchManagedPtr backForwardList + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListGetForwardItemMethodInfo +instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardItemMethodInfo a signature where + overloadedMethod _ = backForwardListGetForwardItem + +#endif + +-- method BackForwardList::get_forward_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_forward_list" webkit_back_forward_list_get_forward_list :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem))) + +{- | +/No description available in the introspection data./ +-} +backForwardListGetForwardList :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m [WebKit2.BackForwardListItem.BackForwardListItem] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of + items following the current item. -} +backForwardListGetForwardList backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_forward_list backForwardList' + result' <- unpackGList result + result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + g_list_free result + touchManagedPtr backForwardList + return result'' + +#if ENABLE_OVERLOADING +data BackForwardListGetForwardListMethodInfo +instance (signature ~ (m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardListMethodInfo a signature where + overloadedMethod _ = backForwardListGetForwardList + +#endif + +-- method BackForwardList::get_forward_list_with_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to retrieve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_forward_list_with_limit" webkit_back_forward_list_get_forward_list_with_limit :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + Word32 -> -- limit : TBasicType TUInt + IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem))) + +{- | +/No description available in the introspection data./ +-} +backForwardListGetForwardListWithLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> Word32 + {- ^ /@limit@/: the number of items to retrieve -} + -> m [WebKit2.BackForwardListItem.BackForwardListItem] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of + items following the current item limited by /@limit@/. -} +backForwardListGetForwardListWithLimit backForwardList limit = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_forward_list_with_limit backForwardList' limit + result' <- unpackGList result + result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + g_list_free result + touchManagedPtr backForwardList + return result'' + +#if ENABLE_OVERLOADING +data BackForwardListGetForwardListWithLimitMethodInfo +instance (signature ~ (Word32 -> m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardListWithLimitMethodInfo a signature where + overloadedMethod _ = backForwardListGetForwardListWithLimit + +#endif + +-- method BackForwardList::get_length +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_length" webkit_back_forward_list_get_length :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + IO Word32 + +{- | +/No description available in the introspection data./ +-} +backForwardListGetLength :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> m Word32 + {- ^ __Returns:__ the length of /@backForwardList@/. -} +backForwardListGetLength backForwardList = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_length backForwardList' + touchManagedPtr backForwardList + return result + +#if ENABLE_OVERLOADING +data BackForwardListGetLengthMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetLengthMethodInfo a signature where + overloadedMethod _ = backForwardListGetLength + +#endif + +-- method BackForwardList::get_nth_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_back_forward_list_get_nth_item" webkit_back_forward_list_get_nth_item :: + Ptr BackForwardList -> -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}) + Int32 -> -- index : TBasicType TInt + IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem) + +{- | +Returns the item at a given index relative to the current item. +-} +backForwardListGetNthItem :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) => + a + {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} + -> Int32 + {- ^ /@index@/: the index of the item -} + -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' + located at the specified index relative to the current item or 'Nothing'. -} +backForwardListGetNthItem backForwardList index = liftIO $ do + backForwardList' <- unsafeManagedPtrCastPtr backForwardList + result <- webkit_back_forward_list_get_nth_item backForwardList' index + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result' + return result'' + touchManagedPtr backForwardList + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListGetNthItemMethodInfo +instance (signature ~ (Int32 -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetNthItemMethodInfo a signature where + overloadedMethod _ = backForwardListGetNthItem + +#endif + + diff --git a/GI/WebKit2/Objects/BackForwardList.hs-boot b/GI/WebKit2/Objects/BackForwardList.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/BackForwardList.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.BackForwardList 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 + +newtype BackForwardList = BackForwardList (ManagedPtr BackForwardList) +instance GObject BackForwardList where +class (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o +instance (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o +instance O.HasParentTypes BackForwardList +#if ENABLE_OVERLOADING +data BackForwardListChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetBackItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetBackListMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetBackListWithLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetCurrentItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetForwardItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetForwardListMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetForwardListWithLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetLengthMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListGetNthItemMethodInfo +#endif diff --git a/GI/WebKit2/Objects/BackForwardListItem.hs b/GI/WebKit2/Objects/BackForwardListItem.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/BackForwardListItem.hs @@ -0,0 +1,267 @@ + + +{- | +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.BackForwardListItem + ( + +-- * Exported types + BackForwardListItem(..) , + IsBackForwardListItem , + toBackForwardListItem , + noBackForwardListItem , + + + -- * Methods +-- ** getOriginalUri #method:getOriginalUri# + +#if ENABLE_OVERLOADING + BackForwardListItemGetOriginalUriMethodInfo, +#endif + backForwardListItemGetOriginalUri , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + BackForwardListItemGetTitleMethodInfo , +#endif + backForwardListItemGetTitle , + + +-- ** getUri #method:getUri# + +#if ENABLE_OVERLOADING + BackForwardListItemGetUriMethodInfo , +#endif + backForwardListItemGetUri , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype BackForwardListItem = BackForwardListItem (ManagedPtr BackForwardListItem) +foreign import ccall "webkit_back_forward_list_item_get_type" + c_webkit_back_forward_list_item_get_type :: IO GType + +instance GObject BackForwardListItem where + gobjectType = c_webkit_back_forward_list_item_get_type + + +-- | Type class for types which can be safely cast to `BackForwardListItem`, for instance with `toBackForwardListItem`. +class (GObject o, O.IsDescendantOf BackForwardListItem o) => IsBackForwardListItem o +instance (GObject o, O.IsDescendantOf BackForwardListItem o) => IsBackForwardListItem o + +instance O.HasParentTypes BackForwardListItem +type instance O.ParentTypes BackForwardListItem = '[GObject.Object.Object] + +-- | Cast to `BackForwardListItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toBackForwardListItem :: (MonadIO m, IsBackForwardListItem o) => o -> m BackForwardListItem +toBackForwardListItem = liftIO . unsafeCastTo BackForwardListItem + +-- | A convenience alias for `Nothing` :: `Maybe` `BackForwardListItem`. +noBackForwardListItem :: Maybe BackForwardListItem +noBackForwardListItem = Nothing + +#if ENABLE_OVERLOADING +type family ResolveBackForwardListItemMethod (t :: Symbol) (o :: *) :: * where + ResolveBackForwardListItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveBackForwardListItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveBackForwardListItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveBackForwardListItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveBackForwardListItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveBackForwardListItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveBackForwardListItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveBackForwardListItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveBackForwardListItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveBackForwardListItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveBackForwardListItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveBackForwardListItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveBackForwardListItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveBackForwardListItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveBackForwardListItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveBackForwardListItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveBackForwardListItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveBackForwardListItemMethod "getOriginalUri" o = BackForwardListItemGetOriginalUriMethodInfo + ResolveBackForwardListItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveBackForwardListItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveBackForwardListItemMethod "getTitle" o = BackForwardListItemGetTitleMethodInfo + ResolveBackForwardListItemMethod "getUri" o = BackForwardListItemGetUriMethodInfo + ResolveBackForwardListItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveBackForwardListItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveBackForwardListItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBackForwardListItemMethod t BackForwardListItem, O.MethodInfo info BackForwardListItem p) => OL.IsLabel t (BackForwardListItem -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BackForwardListItem +type instance O.AttributeList BackForwardListItem = BackForwardListItemAttributeList +type BackForwardListItemAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList BackForwardListItem = BackForwardListItemSignalList +type BackForwardListItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method BackForwardListItem::get_original_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "list_item", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardListItem", 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_back_forward_list_item_get_original_uri" webkit_back_forward_list_item_get_original_uri :: + Ptr BackForwardListItem -> -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}) + IO CString + +{- | +See also 'GI.WebKit2.Objects.BackForwardListItem.backForwardListItemGetUri'. +-} +backForwardListItemGetOriginalUri :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) => + a + {- ^ /@listItem@/: a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the original URI of /@listItem@/ or 'Nothing' + when the original URI is empty. -} +backForwardListItemGetOriginalUri listItem = liftIO $ do + listItem' <- unsafeManagedPtrCastPtr listItem + result <- webkit_back_forward_list_item_get_original_uri listItem' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr listItem + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListItemGetOriginalUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetOriginalUriMethodInfo a signature where + overloadedMethod _ = backForwardListItemGetOriginalUri + +#endif + +-- method BackForwardListItem::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "list_item", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardListItem", 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_back_forward_list_item_get_title" webkit_back_forward_list_item_get_title :: + Ptr BackForwardListItem -> -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +backForwardListItemGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) => + a + {- ^ /@listItem@/: a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the page title of /@listItem@/ or 'Nothing' + when the title is empty. -} +backForwardListItemGetTitle listItem = liftIO $ do + listItem' <- unsafeManagedPtrCastPtr listItem + result <- webkit_back_forward_list_item_get_title listItem' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr listItem + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListItemGetTitleMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetTitleMethodInfo a signature where + overloadedMethod _ = backForwardListItemGetTitle + +#endif + +-- method BackForwardListItem::get_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "list_item", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardListItem", 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_back_forward_list_item_get_uri" webkit_back_forward_list_item_get_uri :: + Ptr BackForwardListItem -> -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}) + IO CString + +{- | +This URI may differ from the original URI if the page was, +for example, redirected to a new location. +See also 'GI.WebKit2.Objects.BackForwardListItem.backForwardListItemGetOriginalUri'. +-} +backForwardListItemGetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) => + a + {- ^ /@listItem@/: a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the URI of /@listItem@/ or 'Nothing' + when the URI is empty. -} +backForwardListItemGetUri listItem = liftIO $ do + listItem' <- unsafeManagedPtrCastPtr listItem + result <- webkit_back_forward_list_item_get_uri listItem' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr listItem + return maybeResult + +#if ENABLE_OVERLOADING +data BackForwardListItemGetUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetUriMethodInfo a signature where + overloadedMethod _ = backForwardListItemGetUri + +#endif + + diff --git a/GI/WebKit2/Objects/BackForwardListItem.hs-boot b/GI/WebKit2/Objects/BackForwardListItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/BackForwardListItem.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.BackForwardListItem 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 + +newtype BackForwardListItem = BackForwardListItem (ManagedPtr BackForwardListItem) +instance GObject BackForwardListItem where +class (GObject o, O.IsDescendantOf BackForwardListItem o) => IsBackForwardListItem o +instance (GObject o, O.IsDescendantOf BackForwardListItem o) => IsBackForwardListItem o +instance O.HasParentTypes BackForwardListItem +#if ENABLE_OVERLOADING +data BackForwardListItemGetOriginalUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListItemGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data BackForwardListItemGetUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/ColorChooserRequest.hs b/GI/WebKit2/Objects/ColorChooserRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ColorChooserRequest.hs @@ -0,0 +1,527 @@ + + +{- | +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.ColorChooserRequest + ( + +-- * Exported types + ColorChooserRequest(..) , + IsColorChooserRequest , + toColorChooserRequest , + noColorChooserRequest , + + + -- * Methods +-- ** cancel #method:cancel# + +#if ENABLE_OVERLOADING + ColorChooserRequestCancelMethodInfo , +#endif + colorChooserRequestCancel , + + +-- ** finish #method:finish# + +#if ENABLE_OVERLOADING + ColorChooserRequestFinishMethodInfo , +#endif + colorChooserRequestFinish , + + +-- ** getElementRectangle #method:getElementRectangle# + +#if ENABLE_OVERLOADING + ColorChooserRequestGetElementRectangleMethodInfo, +#endif + colorChooserRequestGetElementRectangle , + + +-- ** getRgba #method:getRgba# + +#if ENABLE_OVERLOADING + ColorChooserRequestGetRgbaMethodInfo , +#endif + colorChooserRequestGetRgba , + + +-- ** setRgba #method:setRgba# + +#if ENABLE_OVERLOADING + ColorChooserRequestSetRgbaMethodInfo , +#endif + colorChooserRequestSetRgba , + + + + + -- * Properties +-- ** rgba #attr:rgba# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ColorChooserRequestRgbaPropertyInfo , +#endif +#if ENABLE_OVERLOADING + colorChooserRequestRgba , +#endif + constructColorChooserRequestRgba , + getColorChooserRequestRgba , + setColorChooserRequestRgba , + + + + + -- * Signals +-- ** finished #signal:finished# + + C_ColorChooserRequestFinishedCallback , + ColorChooserRequestFinishedCallback , +#if ENABLE_OVERLOADING + ColorChooserRequestFinishedSignalInfo , +#endif + afterColorChooserRequestFinished , + genClosure_ColorChooserRequestFinished , + mk_ColorChooserRequestFinishedCallback , + noColorChooserRequestFinishedCallback , + onColorChooserRequestFinished , + wrap_ColorChooserRequestFinishedCallback, + + + + + ) 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.Gdk.Structs.RGBA as Gdk.RGBA +import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle + +-- | Memory-managed wrapper type. +newtype ColorChooserRequest = ColorChooserRequest (ManagedPtr ColorChooserRequest) +foreign import ccall "webkit_color_chooser_request_get_type" + c_webkit_color_chooser_request_get_type :: IO GType + +instance GObject ColorChooserRequest where + gobjectType = c_webkit_color_chooser_request_get_type + + +-- | Type class for types which can be safely cast to `ColorChooserRequest`, for instance with `toColorChooserRequest`. +class (GObject o, O.IsDescendantOf ColorChooserRequest o) => IsColorChooserRequest o +instance (GObject o, O.IsDescendantOf ColorChooserRequest o) => IsColorChooserRequest o + +instance O.HasParentTypes ColorChooserRequest +type instance O.ParentTypes ColorChooserRequest = '[GObject.Object.Object] + +-- | Cast to `ColorChooserRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toColorChooserRequest :: (MonadIO m, IsColorChooserRequest o) => o -> m ColorChooserRequest +toColorChooserRequest = liftIO . unsafeCastTo ColorChooserRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `ColorChooserRequest`. +noColorChooserRequest :: Maybe ColorChooserRequest +noColorChooserRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveColorChooserRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveColorChooserRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveColorChooserRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveColorChooserRequestMethod "cancel" o = ColorChooserRequestCancelMethodInfo + ResolveColorChooserRequestMethod "finish" o = ColorChooserRequestFinishMethodInfo + ResolveColorChooserRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveColorChooserRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveColorChooserRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveColorChooserRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveColorChooserRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveColorChooserRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveColorChooserRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveColorChooserRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveColorChooserRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveColorChooserRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveColorChooserRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveColorChooserRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveColorChooserRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveColorChooserRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveColorChooserRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveColorChooserRequestMethod "getElementRectangle" o = ColorChooserRequestGetElementRectangleMethodInfo + ResolveColorChooserRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveColorChooserRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveColorChooserRequestMethod "getRgba" o = ColorChooserRequestGetRgbaMethodInfo + ResolveColorChooserRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveColorChooserRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveColorChooserRequestMethod "setRgba" o = ColorChooserRequestSetRgbaMethodInfo + ResolveColorChooserRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveColorChooserRequestMethod t ColorChooserRequest, O.MethodInfo info ColorChooserRequest p) => OL.IsLabel t (ColorChooserRequest -> 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 ColorChooserRequest::finished +{- | +Emitted when the /@request@/ finishes. This signal can be emitted because the +user completed the /@request@/ calling 'GI.WebKit2.Objects.ColorChooserRequest.colorChooserRequestFinish', +or cancelled it with 'GI.WebKit2.Objects.ColorChooserRequest.colorChooserRequestCancel' or because the +color input element is removed from the DOM. + +/Since: 2.8/ +-} +type ColorChooserRequestFinishedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ColorChooserRequestFinishedCallback`@. +noColorChooserRequestFinishedCallback :: Maybe ColorChooserRequestFinishedCallback +noColorChooserRequestFinishedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ColorChooserRequestFinishedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ColorChooserRequestFinishedCallback`. +foreign import ccall "wrapper" + mk_ColorChooserRequestFinishedCallback :: C_ColorChooserRequestFinishedCallback -> IO (FunPtr C_ColorChooserRequestFinishedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ColorChooserRequestFinished :: MonadIO m => ColorChooserRequestFinishedCallback -> m (GClosure C_ColorChooserRequestFinishedCallback) +genClosure_ColorChooserRequestFinished cb = liftIO $ do + let cb' = wrap_ColorChooserRequestFinishedCallback cb + mk_ColorChooserRequestFinishedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ColorChooserRequestFinishedCallback` into a `C_ColorChooserRequestFinishedCallback`. +wrap_ColorChooserRequestFinishedCallback :: + ColorChooserRequestFinishedCallback -> + C_ColorChooserRequestFinishedCallback +wrap_ColorChooserRequestFinishedCallback _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' colorChooserRequest #finished callback +@ +-} +onColorChooserRequestFinished :: (IsColorChooserRequest a, MonadIO m) => a -> ColorChooserRequestFinishedCallback -> m SignalHandlerId +onColorChooserRequestFinished obj cb = liftIO $ do + let cb' = wrap_ColorChooserRequestFinishedCallback cb + cb'' <- mk_ColorChooserRequestFinishedCallback 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' colorChooserRequest #finished callback +@ +-} +afterColorChooserRequestFinished :: (IsColorChooserRequest a, MonadIO m) => a -> ColorChooserRequestFinishedCallback -> m SignalHandlerId +afterColorChooserRequestFinished obj cb = liftIO $ do + let cb' = wrap_ColorChooserRequestFinishedCallback cb + cb'' <- mk_ColorChooserRequestFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' SignalConnectAfter + + +-- VVV Prop "rgba" + -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@rgba@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' colorChooserRequest #rgba +@ +-} +getColorChooserRequestRgba :: (MonadIO m, IsColorChooserRequest o) => o -> m (Maybe Gdk.RGBA.RGBA) +getColorChooserRequestRgba obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "rgba" Gdk.RGBA.RGBA + +{- | +Set the value of the “@rgba@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' colorChooserRequest [ #rgba 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setColorChooserRequestRgba :: (MonadIO m, IsColorChooserRequest o) => o -> Gdk.RGBA.RGBA -> m () +setColorChooserRequestRgba obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "rgba" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructColorChooserRequestRgba :: (IsColorChooserRequest o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o) +constructColorChooserRequestRgba val = B.Properties.constructObjectPropertyBoxed "rgba" (Just val) + +#if ENABLE_OVERLOADING +data ColorChooserRequestRgbaPropertyInfo +instance AttrInfo ColorChooserRequestRgbaPropertyInfo where + type AttrAllowedOps ColorChooserRequestRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ColorChooserRequestRgbaPropertyInfo = (~) Gdk.RGBA.RGBA + type AttrBaseTypeConstraint ColorChooserRequestRgbaPropertyInfo = IsColorChooserRequest + type AttrGetType ColorChooserRequestRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA) + type AttrLabel ColorChooserRequestRgbaPropertyInfo = "rgba" + type AttrOrigin ColorChooserRequestRgbaPropertyInfo = ColorChooserRequest + attrGet _ = getColorChooserRequestRgba + attrSet _ = setColorChooserRequestRgba + attrConstruct _ = constructColorChooserRequestRgba + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ColorChooserRequest +type instance O.AttributeList ColorChooserRequest = ColorChooserRequestAttributeList +type ColorChooserRequestAttributeList = ('[ '("rgba", ColorChooserRequestRgbaPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +colorChooserRequestRgba :: AttrLabelProxy "rgba" +colorChooserRequestRgba = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data ColorChooserRequestFinishedSignalInfo +instance SignalInfo ColorChooserRequestFinishedSignalInfo where + type HaskellCallbackType ColorChooserRequestFinishedSignalInfo = ColorChooserRequestFinishedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ColorChooserRequestFinishedCallback cb + cb'' <- mk_ColorChooserRequestFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' connectMode + +type instance O.SignalList ColorChooserRequest = ColorChooserRequestSignalList +type ColorChooserRequestSignalList = ('[ '("finished", ColorChooserRequestFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ColorChooserRequest::cancel +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitColorChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_color_chooser_request_cancel" webkit_color_chooser_request_cancel :: + Ptr ColorChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}) + IO () + +{- | +Cancels /@request@/ and the input element changes to use the initial color +it has before the request started. +The signal 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest'::@/finished/@ +is emitted to notify that the request has finished. + +/Since: 2.8/ +-} +colorChooserRequestCancel :: + (B.CallStack.HasCallStack, MonadIO m, IsColorChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -} + -> m () +colorChooserRequestCancel request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_color_chooser_request_cancel request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data ColorChooserRequestCancelMethodInfo +instance (signature ~ (m ()), MonadIO m, IsColorChooserRequest a) => O.MethodInfo ColorChooserRequestCancelMethodInfo a signature where + overloadedMethod _ = colorChooserRequestCancel + +#endif + +-- method ColorChooserRequest::finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitColorChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_color_chooser_request_finish" webkit_color_chooser_request_finish :: + Ptr ColorChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}) + IO () + +{- | +Finishes /@request@/ and the input element keeps the current value of +'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest':@/rgba/@. +The signal 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest'::@/finished/@ +is emitted to notify that the request has finished. + +/Since: 2.8/ +-} +colorChooserRequestFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsColorChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -} + -> m () +colorChooserRequestFinish request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_color_chooser_request_finish request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data ColorChooserRequestFinishMethodInfo +instance (signature ~ (m ()), MonadIO m, IsColorChooserRequest a) => O.MethodInfo ColorChooserRequestFinishMethodInfo a signature where + overloadedMethod _ = colorChooserRequestFinish + +#endif + +-- method ColorChooserRequest::get_element_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitColorChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to fill in with the element area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_color_chooser_request_get_element_rectangle" webkit_color_chooser_request_get_element_rectangle :: + Ptr ColorChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}) + Ptr Gdk.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + IO () + +{- | +Gets the bounding box of the color input element. + +/Since: 2.8/ +-} +colorChooserRequestGetElementRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsColorChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -} + -> m (Gdk.Rectangle.Rectangle) +colorChooserRequestGetElementRectangle request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle) + webkit_color_chooser_request_get_element_rectangle request' rect + rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect + touchManagedPtr request + return rect' + +#if ENABLE_OVERLOADING +data ColorChooserRequestGetElementRectangleMethodInfo +instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsColorChooserRequest a) => O.MethodInfo ColorChooserRequestGetElementRectangleMethodInfo a signature where + overloadedMethod _ = colorChooserRequestGetElementRectangle + +#endif + +-- method ColorChooserRequest::get_rgba +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitColorChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA to fill in with the current color.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_color_chooser_request_get_rgba" webkit_color_chooser_request_get_rgba :: + Ptr ColorChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}) + Ptr Gdk.RGBA.RGBA -> -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Gets the current 'GI.Gdk.Structs.RGBA.RGBA' color of /@request@/ + +/Since: 2.8/ +-} +colorChooserRequestGetRgba :: + (B.CallStack.HasCallStack, MonadIO m, IsColorChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -} + -> m (Gdk.RGBA.RGBA) +colorChooserRequestGetRgba request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + rgba <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA) + webkit_color_chooser_request_get_rgba request' rgba + rgba' <- (wrapBoxed Gdk.RGBA.RGBA) rgba + touchManagedPtr request + return rgba' + +#if ENABLE_OVERLOADING +data ColorChooserRequestGetRgbaMethodInfo +instance (signature ~ (m (Gdk.RGBA.RGBA)), MonadIO m, IsColorChooserRequest a) => O.MethodInfo ColorChooserRequestGetRgbaMethodInfo a signature where + overloadedMethod _ = colorChooserRequestGetRgba + +#endif + +-- method ColorChooserRequest::set_rgba +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkRGBA", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_color_chooser_request_set_rgba" webkit_color_chooser_request_set_rgba :: + Ptr ColorChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "ColorChooserRequest"}) + Ptr Gdk.RGBA.RGBA -> -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Sets the current 'GI.Gdk.Structs.RGBA.RGBA' color of /@request@/ + +/Since: 2.8/ +-} +colorChooserRequestSetRgba :: + (B.CallStack.HasCallStack, MonadIO m, IsColorChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> Gdk.RGBA.RGBA + {- ^ /@rgba@/: a pointer 'GI.Gdk.Structs.RGBA.RGBA' -} + -> m () +colorChooserRequestSetRgba request rgba = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + rgba' <- unsafeManagedPtrGetPtr rgba + webkit_color_chooser_request_set_rgba request' rgba' + touchManagedPtr request + touchManagedPtr rgba + return () + +#if ENABLE_OVERLOADING +data ColorChooserRequestSetRgbaMethodInfo +instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsColorChooserRequest a) => O.MethodInfo ColorChooserRequestSetRgbaMethodInfo a signature where + overloadedMethod _ = colorChooserRequestSetRgba + +#endif + + diff --git a/GI/WebKit2/Objects/ColorChooserRequest.hs-boot b/GI/WebKit2/Objects/ColorChooserRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ColorChooserRequest.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.ColorChooserRequest 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 + +newtype ColorChooserRequest = ColorChooserRequest (ManagedPtr ColorChooserRequest) +instance GObject ColorChooserRequest where +class (GObject o, O.IsDescendantOf ColorChooserRequest o) => IsColorChooserRequest o +instance (GObject o, O.IsDescendantOf ColorChooserRequest o) => IsColorChooserRequest o +instance O.HasParentTypes ColorChooserRequest +#if ENABLE_OVERLOADING +data ColorChooserRequestRgbaPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestFinishedSignalInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestCancelMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestGetElementRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestGetRgbaMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorChooserRequestSetRgbaMethodInfo +#endif diff --git a/GI/WebKit2/Objects/ContextMenu.hs b/GI/WebKit2/Objects/ContextMenu.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ContextMenu.hs @@ -0,0 +1,830 @@ + + +{- | +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.ContextMenu + ( + +-- * Exported types + ContextMenu(..) , + IsContextMenu , + toContextMenu , + noContextMenu , + + + -- * Methods +-- ** append #method:append# + +#if ENABLE_OVERLOADING + ContextMenuAppendMethodInfo , +#endif + contextMenuAppend , + + +-- ** first #method:first# + +#if ENABLE_OVERLOADING + ContextMenuFirstMethodInfo , +#endif + contextMenuFirst , + + +-- ** getItemAtPosition #method:getItemAtPosition# + +#if ENABLE_OVERLOADING + ContextMenuGetItemAtPositionMethodInfo , +#endif + contextMenuGetItemAtPosition , + + +-- ** getItems #method:getItems# + +#if ENABLE_OVERLOADING + ContextMenuGetItemsMethodInfo , +#endif + contextMenuGetItems , + + +-- ** getNItems #method:getNItems# + +#if ENABLE_OVERLOADING + ContextMenuGetNItemsMethodInfo , +#endif + contextMenuGetNItems , + + +-- ** getUserData #method:getUserData# + +#if ENABLE_OVERLOADING + ContextMenuGetUserDataMethodInfo , +#endif + contextMenuGetUserData , + + +-- ** insert #method:insert# + +#if ENABLE_OVERLOADING + ContextMenuInsertMethodInfo , +#endif + contextMenuInsert , + + +-- ** last #method:last# + +#if ENABLE_OVERLOADING + ContextMenuLastMethodInfo , +#endif + contextMenuLast , + + +-- ** moveItem #method:moveItem# + +#if ENABLE_OVERLOADING + ContextMenuMoveItemMethodInfo , +#endif + contextMenuMoveItem , + + +-- ** new #method:new# + + contextMenuNew , + + +-- ** newWithItems #method:newWithItems# + + contextMenuNewWithItems , + + +-- ** prepend #method:prepend# + +#if ENABLE_OVERLOADING + ContextMenuPrependMethodInfo , +#endif + contextMenuPrepend , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + ContextMenuRemoveMethodInfo , +#endif + contextMenuRemove , + + +-- ** removeAll #method:removeAll# + +#if ENABLE_OVERLOADING + ContextMenuRemoveAllMethodInfo , +#endif + contextMenuRemoveAll , + + +-- ** setUserData #method:setUserData# + +#if ENABLE_OVERLOADING + ContextMenuSetUserDataMethodInfo , +#endif + contextMenuSetUserData , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.ContextMenuItem as WebKit2.ContextMenuItem + +-- | Memory-managed wrapper type. +newtype ContextMenu = ContextMenu (ManagedPtr ContextMenu) +foreign import ccall "webkit_context_menu_get_type" + c_webkit_context_menu_get_type :: IO GType + +instance GObject ContextMenu where + gobjectType = c_webkit_context_menu_get_type + + +-- | Type class for types which can be safely cast to `ContextMenu`, for instance with `toContextMenu`. +class (GObject o, O.IsDescendantOf ContextMenu o) => IsContextMenu o +instance (GObject o, O.IsDescendantOf ContextMenu o) => IsContextMenu o + +instance O.HasParentTypes ContextMenu +type instance O.ParentTypes ContextMenu = '[GObject.Object.Object] + +-- | Cast to `ContextMenu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toContextMenu :: (MonadIO m, IsContextMenu o) => o -> m ContextMenu +toContextMenu = liftIO . unsafeCastTo ContextMenu + +-- | A convenience alias for `Nothing` :: `Maybe` `ContextMenu`. +noContextMenu :: Maybe ContextMenu +noContextMenu = Nothing + +#if ENABLE_OVERLOADING +type family ResolveContextMenuMethod (t :: Symbol) (o :: *) :: * where + ResolveContextMenuMethod "append" o = ContextMenuAppendMethodInfo + ResolveContextMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveContextMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveContextMenuMethod "first" o = ContextMenuFirstMethodInfo + ResolveContextMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveContextMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveContextMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveContextMenuMethod "insert" o = ContextMenuInsertMethodInfo + ResolveContextMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveContextMenuMethod "last" o = ContextMenuLastMethodInfo + ResolveContextMenuMethod "moveItem" o = ContextMenuMoveItemMethodInfo + ResolveContextMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveContextMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveContextMenuMethod "prepend" o = ContextMenuPrependMethodInfo + ResolveContextMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveContextMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveContextMenuMethod "remove" o = ContextMenuRemoveMethodInfo + ResolveContextMenuMethod "removeAll" o = ContextMenuRemoveAllMethodInfo + ResolveContextMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveContextMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveContextMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveContextMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveContextMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveContextMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveContextMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveContextMenuMethod "getItemAtPosition" o = ContextMenuGetItemAtPositionMethodInfo + ResolveContextMenuMethod "getItems" o = ContextMenuGetItemsMethodInfo + ResolveContextMenuMethod "getNItems" o = ContextMenuGetNItemsMethodInfo + ResolveContextMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveContextMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveContextMenuMethod "getUserData" o = ContextMenuGetUserDataMethodInfo + ResolveContextMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveContextMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveContextMenuMethod "setUserData" o = ContextMenuSetUserDataMethodInfo + ResolveContextMenuMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveContextMenuMethod t ContextMenu, O.MethodInfo info ContextMenu p) => OL.IsLabel t (ContextMenu -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ContextMenu +type instance O.AttributeList ContextMenu = ContextMenuAttributeList +type ContextMenuAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ContextMenu = ContextMenuSignalList +type ContextMenuSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ContextMenu::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenu"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_new" webkit_context_menu_new :: + IO (Ptr ContextMenu) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenu.ContextMenu' object to be used as a submenu of an existing +'GI.WebKit2.Objects.ContextMenu.ContextMenu'. The context menu of a 'GI.WebKit2.Objects.WebView.WebView' is created by the view +and passed as an argument of 'GI.WebKit2.Objects.WebView.WebView'::@/context-menu/@ signal. +To add items to the menu use 'GI.WebKit2.Objects.ContextMenu.contextMenuPrepend', +'GI.WebKit2.Objects.ContextMenu.contextMenuAppend' or 'GI.WebKit2.Objects.ContextMenu.contextMenuInsert'. +See also 'GI.WebKit2.Objects.ContextMenu.contextMenuNewWithItems' to create a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' with +a list of initial items. +-} +contextMenuNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m ContextMenu + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.ContextMenu.ContextMenu' object -} +contextMenuNew = liftIO $ do + result <- webkit_context_menu_new + checkUnexpectedReturnNULL "contextMenuNew" result + result' <- (wrapObject ContextMenu) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenu::new_with_items +-- method type : Constructor +-- Args : [Arg {argCName = "items", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenu"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_new_with_items" webkit_context_menu_new_with_items :: + Ptr (GList (Ptr WebKit2.ContextMenuItem.ContextMenuItem)) -> -- items : TGList (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) + IO (Ptr ContextMenu) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenu.ContextMenu' object to be used as a submenu of an existing +'GI.WebKit2.Objects.ContextMenu.ContextMenu' with the given initial items. +See also 'GI.WebKit2.Objects.ContextMenu.contextMenuNew' +-} +contextMenuNewWithItems :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.ContextMenuItem.IsContextMenuItem a) => + [a] + {- ^ /@items@/: a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m ContextMenu + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.ContextMenu.ContextMenu' object -} +contextMenuNewWithItems items = liftIO $ do + items' <- mapM unsafeManagedPtrCastPtr items + items'' <- packGList items' + result <- webkit_context_menu_new_with_items items'' + checkUnexpectedReturnNULL "contextMenuNewWithItems" result + result' <- (wrapObject ContextMenu) result + mapM_ touchManagedPtr items + g_list_free items'' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenu::append +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitContextMenuItem to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_append" webkit_context_menu_append :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr WebKit2.ContextMenuItem.ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO () + +{- | +Adds /@item@/ at the end of the /@menu@/. +-} +contextMenuAppend :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> b + {- ^ /@item@/: the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' to add -} + -> m () +contextMenuAppend menu item = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + item' <- unsafeManagedPtrCastPtr item + webkit_context_menu_append menu' item' + touchManagedPtr menu + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data ContextMenuAppendMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => O.MethodInfo ContextMenuAppendMethodInfo a signature where + overloadedMethod _ = contextMenuAppend + +#endif + +-- method ContextMenu::first +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_first" webkit_context_menu_first :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO (Ptr WebKit2.ContextMenuItem.ContextMenuItem) + +{- | +Gets the first item in the /@menu@/. +-} +contextMenuFirst :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m (Maybe WebKit2.ContextMenuItem.ContextMenuItem) + {- ^ __Returns:__ the first 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' of /@menu@/, + or 'Nothing' if the 'GI.WebKit2.Objects.ContextMenu.ContextMenu' is empty. -} +contextMenuFirst menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_first menu' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.ContextMenuItem.ContextMenuItem) result' + return result'' + touchManagedPtr menu + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuFirstMethodInfo +instance (signature ~ (m (Maybe WebKit2.ContextMenuItem.ContextMenuItem)), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuFirstMethodInfo a signature where + overloadedMethod _ = contextMenuFirst + +#endif + +-- method ContextMenu::get_item_at_position +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position of the item, counting from 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_get_item_at_position" webkit_context_menu_get_item_at_position :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Word32 -> -- position : TBasicType TUInt + IO (Ptr WebKit2.ContextMenuItem.ContextMenuItem) + +{- | +Gets the item at the given position in the /@menu@/. +-} +contextMenuGetItemAtPosition :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> Word32 + {- ^ /@position@/: the position of the item, counting from 0 -} + -> m (Maybe WebKit2.ContextMenuItem.ContextMenuItem) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' at position /@position@/ in /@menu@/, + or 'Nothing' if the position is off the end of the /@menu@/. -} +contextMenuGetItemAtPosition menu position = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_get_item_at_position menu' position + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.ContextMenuItem.ContextMenuItem) result' + return result'' + touchManagedPtr menu + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuGetItemAtPositionMethodInfo +instance (signature ~ (Word32 -> m (Maybe WebKit2.ContextMenuItem.ContextMenuItem)), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuGetItemAtPositionMethodInfo a signature where + overloadedMethod _ = contextMenuGetItemAtPosition + +#endif + +-- method ContextMenu::get_items +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_get_items" webkit_context_menu_get_items :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO (Ptr (GList (Ptr WebKit2.ContextMenuItem.ContextMenuItem))) + +{- | +Returns the item list of /@menu@/. +-} +contextMenuGetItems :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m [WebKit2.ContextMenuItem.ContextMenuItem] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of + 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem'\s -} +contextMenuGetItems menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_get_items menu' + result' <- unpackGList result + result'' <- mapM (newObject WebKit2.ContextMenuItem.ContextMenuItem) result' + touchManagedPtr menu + return result'' + +#if ENABLE_OVERLOADING +data ContextMenuGetItemsMethodInfo +instance (signature ~ (m [WebKit2.ContextMenuItem.ContextMenuItem]), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuGetItemsMethodInfo a signature where + overloadedMethod _ = contextMenuGetItems + +#endif + +-- method ContextMenu::get_n_items +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_get_n_items" webkit_context_menu_get_n_items :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO Word32 + +{- | +Gets the length of the /@menu@/. +-} +contextMenuGetNItems :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m Word32 + {- ^ __Returns:__ the number of 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem'\s in /@menu@/ -} +contextMenuGetNItems menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_get_n_items menu' + touchManagedPtr menu + return result + +#if ENABLE_OVERLOADING +data ContextMenuGetNItemsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuGetNItemsMethodInfo a signature where + overloadedMethod _ = contextMenuGetNItems + +#endif + +-- method ContextMenu::get_user_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_get_user_data" webkit_context_menu_get_user_data :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO (Ptr GVariant) + +{- | +Gets the user data of /@menu@/. +This function can be used from the UI Process to get user data previously set +from the Web Process with 'GI.WebKit2.Objects.ContextMenu.contextMenuSetUserData'. + +/Since: 2.8/ +-} +contextMenuGetUserData :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m (Maybe GVariant) + {- ^ __Returns:__ the user data of /@menu@/, or 'Nothing' if /@menu@/ doesn\'t have user data -} +contextMenuGetUserData menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_get_user_data menu' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- B.GVariant.newGVariantFromPtr result' + return result'' + touchManagedPtr menu + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuGetUserDataMethodInfo +instance (signature ~ (m (Maybe GVariant)), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuGetUserDataMethodInfo a signature where + overloadedMethod _ = contextMenuGetUserData + +#endif + +-- method ContextMenu::insert +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitContextMenuItem to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to insert the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_insert" webkit_context_menu_insert :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr WebKit2.ContextMenuItem.ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + Int32 -> -- position : TBasicType TInt + IO () + +{- | +Inserts /@item@/ into the /@menu@/ at the given position. +If /@position@/ is negative, or is larger than the number of items +in the 'GI.WebKit2.Objects.ContextMenu.ContextMenu', the item is added on to the end of +the /@menu@/. The first position is 0. +-} +contextMenuInsert :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> b + {- ^ /@item@/: the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' to add -} + -> Int32 + {- ^ /@position@/: the position to insert the item -} + -> m () +contextMenuInsert menu item position = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + item' <- unsafeManagedPtrCastPtr item + webkit_context_menu_insert menu' item' position + touchManagedPtr menu + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data ContextMenuInsertMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => O.MethodInfo ContextMenuInsertMethodInfo a signature where + overloadedMethod _ = contextMenuInsert + +#endif + +-- method ContextMenu::last +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_last" webkit_context_menu_last :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO (Ptr WebKit2.ContextMenuItem.ContextMenuItem) + +{- | +Gets the last item in the /@menu@/. +-} +contextMenuLast :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m (Maybe WebKit2.ContextMenuItem.ContextMenuItem) + {- ^ __Returns:__ the last 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' of /@menu@/, + or 'Nothing' if the 'GI.WebKit2.Objects.ContextMenu.ContextMenu' is empty. -} +contextMenuLast menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_context_menu_last menu' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.ContextMenuItem.ContextMenuItem) result' + return result'' + touchManagedPtr menu + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuLastMethodInfo +instance (signature ~ (m (Maybe WebKit2.ContextMenuItem.ContextMenuItem)), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuLastMethodInfo a signature where + overloadedMethod _ = contextMenuLast + +#endif + +-- method ContextMenu::move_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitContextMenuItem to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new position to move the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_move_item" webkit_context_menu_move_item :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr WebKit2.ContextMenuItem.ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + Int32 -> -- position : TBasicType TInt + IO () + +{- | +Moves /@item@/ to the given position in the /@menu@/. +If /@position@/ is negative, or is larger than the number of items +in the 'GI.WebKit2.Objects.ContextMenu.ContextMenu', the item is added on to the end of +the /@menu@/. +The first position is 0. +-} +contextMenuMoveItem :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> b + {- ^ /@item@/: the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' to add -} + -> Int32 + {- ^ /@position@/: the new position to move the item -} + -> m () +contextMenuMoveItem menu item position = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + item' <- unsafeManagedPtrCastPtr item + webkit_context_menu_move_item menu' item' position + touchManagedPtr menu + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data ContextMenuMoveItemMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => O.MethodInfo ContextMenuMoveItemMethodInfo a signature where + overloadedMethod _ = contextMenuMoveItem + +#endif + +-- method ContextMenu::prepend +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitContextMenuItem to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_prepend" webkit_context_menu_prepend :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr WebKit2.ContextMenuItem.ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO () + +{- | +Adds /@item@/ at the beginning of the /@menu@/. +-} +contextMenuPrepend :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> b + {- ^ /@item@/: the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' to add -} + -> m () +contextMenuPrepend menu item = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + item' <- unsafeManagedPtrCastPtr item + webkit_context_menu_prepend menu' item' + touchManagedPtr menu + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data ContextMenuPrependMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => O.MethodInfo ContextMenuPrependMethodInfo a signature where + overloadedMethod _ = contextMenuPrepend + +#endif + +-- method ContextMenu::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitContextMenuItem to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_remove" webkit_context_menu_remove :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr WebKit2.ContextMenuItem.ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO () + +{- | +Removes /@item@/ from the /@menu@/. +See also 'GI.WebKit2.Objects.ContextMenu.contextMenuRemoveAll' to remove all items. +-} +contextMenuRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> b + {- ^ /@item@/: the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' to remove -} + -> m () +contextMenuRemove menu item = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + item' <- unsafeManagedPtrCastPtr item + webkit_context_menu_remove menu' item' + touchManagedPtr menu + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data ContextMenuRemoveMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsContextMenu a, WebKit2.ContextMenuItem.IsContextMenuItem b) => O.MethodInfo ContextMenuRemoveMethodInfo a signature where + overloadedMethod _ = contextMenuRemove + +#endif + +-- method ContextMenu::remove_all +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_remove_all" webkit_context_menu_remove_all :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO () + +{- | +Removes all items of the /@menu@/. +-} +contextMenuRemoveAll :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m () +contextMenuRemoveAll menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + webkit_context_menu_remove_all menu' + touchManagedPtr menu + return () + +#if ENABLE_OVERLOADING +data ContextMenuRemoveAllMethodInfo +instance (signature ~ (m ()), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuRemoveAllMethodInfo a signature where + overloadedMethod _ = contextMenuRemoveAll + +#endif + +-- method ContextMenu::set_user_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVariant", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_set_user_data" webkit_context_menu_set_user_data :: + Ptr ContextMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + Ptr GVariant -> -- user_data : TVariant + IO () + +{- | +Sets user data to /@menu@/. +This function can be used from a Web Process extension to set user data +that can be retrieved from the UI Process using 'GI.WebKit2.Objects.ContextMenu.contextMenuGetUserData'. +If the /@userData@/ 'GVariant' is floating, it is consumed. + +/Since: 2.8/ +-} +contextMenuSetUserData :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> GVariant + {- ^ /@userData@/: a 'GVariant' -} + -> m () +contextMenuSetUserData menu userData = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + userData' <- unsafeManagedPtrGetPtr userData + webkit_context_menu_set_user_data menu' userData' + touchManagedPtr menu + touchManagedPtr userData + return () + +#if ENABLE_OVERLOADING +data ContextMenuSetUserDataMethodInfo +instance (signature ~ (GVariant -> m ()), MonadIO m, IsContextMenu a) => O.MethodInfo ContextMenuSetUserDataMethodInfo a signature where + overloadedMethod _ = contextMenuSetUserData + +#endif + + diff --git a/GI/WebKit2/Objects/ContextMenu.hs-boot b/GI/WebKit2/Objects/ContextMenu.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ContextMenu.hs-boot @@ -0,0 +1,68 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.ContextMenu 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 + +newtype ContextMenu = ContextMenu (ManagedPtr ContextMenu) +instance GObject ContextMenu where +class (GObject o, O.IsDescendantOf ContextMenu o) => IsContextMenu o +instance (GObject o, O.IsDescendantOf ContextMenu o) => IsContextMenu o +instance O.HasParentTypes ContextMenu +#if ENABLE_OVERLOADING +data ContextMenuAppendMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuFirstMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuGetItemAtPositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuGetItemsMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuGetNItemsMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuGetUserDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuInsertMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuLastMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuMoveItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuPrependMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuRemoveAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuSetUserDataMethodInfo +#endif diff --git a/GI/WebKit2/Objects/ContextMenuItem.hs b/GI/WebKit2/Objects/ContextMenuItem.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ContextMenuItem.hs @@ -0,0 +1,668 @@ + + +{- | +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.ContextMenuItem + ( + +-- * Exported types + ContextMenuItem(..) , + IsContextMenuItem , + toContextMenuItem , + noContextMenuItem , + + + -- * Methods +-- ** getAction #method:getAction# + +#if ENABLE_OVERLOADING + ContextMenuItemGetActionMethodInfo , +#endif + contextMenuItemGetAction , + + +-- ** getGaction #method:getGaction# + +#if ENABLE_OVERLOADING + ContextMenuItemGetGactionMethodInfo , +#endif + contextMenuItemGetGaction , + + +-- ** getStockAction #method:getStockAction# + +#if ENABLE_OVERLOADING + ContextMenuItemGetStockActionMethodInfo , +#endif + contextMenuItemGetStockAction , + + +-- ** getSubmenu #method:getSubmenu# + +#if ENABLE_OVERLOADING + ContextMenuItemGetSubmenuMethodInfo , +#endif + contextMenuItemGetSubmenu , + + +-- ** isSeparator #method:isSeparator# + +#if ENABLE_OVERLOADING + ContextMenuItemIsSeparatorMethodInfo , +#endif + contextMenuItemIsSeparator , + + +-- ** new #method:new# + + contextMenuItemNew , + + +-- ** newFromGaction #method:newFromGaction# + + contextMenuItemNewFromGaction , + + +-- ** newFromStockAction #method:newFromStockAction# + + contextMenuItemNewFromStockAction , + + +-- ** newFromStockActionWithLabel #method:newFromStockActionWithLabel# + + contextMenuItemNewFromStockActionWithLabel, + + +-- ** newSeparator #method:newSeparator# + + contextMenuItemNewSeparator , + + +-- ** newWithSubmenu #method:newWithSubmenu# + + contextMenuItemNewWithSubmenu , + + +-- ** setSubmenu #method:setSubmenu# + +#if ENABLE_OVERLOADING + ContextMenuItemSetSubmenuMethodInfo , +#endif + contextMenuItemSetSubmenu , + + + + + ) 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.Interfaces.Action as Gio.Action +import qualified GI.Gtk.Objects.Action as Gtk.Action +import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Objects.ContextMenu as WebKit2.ContextMenu + +-- | Memory-managed wrapper type. +newtype ContextMenuItem = ContextMenuItem (ManagedPtr ContextMenuItem) +foreign import ccall "webkit_context_menu_item_get_type" + c_webkit_context_menu_item_get_type :: IO GType + +instance GObject ContextMenuItem where + gobjectType = c_webkit_context_menu_item_get_type + + +-- | Type class for types which can be safely cast to `ContextMenuItem`, for instance with `toContextMenuItem`. +class (GObject o, O.IsDescendantOf ContextMenuItem o) => IsContextMenuItem o +instance (GObject o, O.IsDescendantOf ContextMenuItem o) => IsContextMenuItem o + +instance O.HasParentTypes ContextMenuItem +type instance O.ParentTypes ContextMenuItem = '[GObject.Object.Object] + +-- | Cast to `ContextMenuItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toContextMenuItem :: (MonadIO m, IsContextMenuItem o) => o -> m ContextMenuItem +toContextMenuItem = liftIO . unsafeCastTo ContextMenuItem + +-- | A convenience alias for `Nothing` :: `Maybe` `ContextMenuItem`. +noContextMenuItem :: Maybe ContextMenuItem +noContextMenuItem = Nothing + +#if ENABLE_OVERLOADING +type family ResolveContextMenuItemMethod (t :: Symbol) (o :: *) :: * where + ResolveContextMenuItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveContextMenuItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveContextMenuItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveContextMenuItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveContextMenuItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveContextMenuItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveContextMenuItemMethod "isSeparator" o = ContextMenuItemIsSeparatorMethodInfo + ResolveContextMenuItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveContextMenuItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveContextMenuItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveContextMenuItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveContextMenuItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveContextMenuItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveContextMenuItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveContextMenuItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveContextMenuItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveContextMenuItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveContextMenuItemMethod "getAction" o = ContextMenuItemGetActionMethodInfo + ResolveContextMenuItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveContextMenuItemMethod "getGaction" o = ContextMenuItemGetGactionMethodInfo + ResolveContextMenuItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveContextMenuItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveContextMenuItemMethod "getStockAction" o = ContextMenuItemGetStockActionMethodInfo + ResolveContextMenuItemMethod "getSubmenu" o = ContextMenuItemGetSubmenuMethodInfo + ResolveContextMenuItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveContextMenuItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveContextMenuItemMethod "setSubmenu" o = ContextMenuItemSetSubmenuMethodInfo + ResolveContextMenuItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveContextMenuItemMethod t ContextMenuItem, O.MethodInfo info ContextMenuItem p) => OL.IsLabel t (ContextMenuItem -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ContextMenuItem +type instance O.AttributeList ContextMenuItem = ContextMenuItemAttributeList +type ContextMenuItemAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ContextMenuItem = ContextMenuItemSignalList +type ContextMenuItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ContextMenuItem::new +-- method type : Constructor +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new" webkit_context_menu_item_new :: + Ptr Gtk.Action.Action -> -- action : TInterface (Name {namespace = "Gtk", name = "Action"}) + IO (Ptr ContextMenuItem) + +{-# DEPRECATED contextMenuItemNew ["(Since version 2.18)","Use 'GI.WebKit2.Objects.ContextMenuItem.contextMenuItemNewFromGaction' instead."] #-} +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' for the given /@action@/. +-} +contextMenuItemNew :: + (B.CallStack.HasCallStack, MonadIO m, Gtk.Action.IsAction a) => + a + {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -} + -> m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNew action = liftIO $ do + action' <- unsafeManagedPtrCastPtr action + result <- webkit_context_menu_item_new action' + checkUnexpectedReturnNULL "contextMenuItemNew" result + result' <- (newObject ContextMenuItem) result + touchManagedPtr action + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::new_from_gaction +-- method type : Constructor +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the menu item label text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant to use as the action target", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new_from_gaction" webkit_context_menu_item_new_from_gaction :: + Ptr Gio.Action.Action -> -- action : TInterface (Name {namespace = "Gio", name = "Action"}) + CString -> -- label : TBasicType TUTF8 + Ptr GVariant -> -- target : TVariant + IO (Ptr ContextMenuItem) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' for the given /@action@/ and /@label@/. On activation +/@target@/ will be passed as parameter to the callback. + +/Since: 2.18/ +-} +contextMenuItemNewFromGaction :: + (B.CallStack.HasCallStack, MonadIO m, Gio.Action.IsAction a) => + a + {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -} + -> T.Text + {- ^ /@label@/: the menu item label text -} + -> Maybe (GVariant) + {- ^ /@target@/: a 'GVariant' to use as the action target -} + -> m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNewFromGaction action label target = liftIO $ do + action' <- unsafeManagedPtrCastPtr action + label' <- textToCString label + maybeTarget <- case target of + Nothing -> return nullPtr + Just jTarget -> do + jTarget' <- unsafeManagedPtrGetPtr jTarget + return jTarget' + result <- webkit_context_menu_item_new_from_gaction action' label' maybeTarget + checkUnexpectedReturnNULL "contextMenuItemNewFromGaction" result + result' <- (newObject ContextMenuItem) result + touchManagedPtr action + whenJust target touchManagedPtr + freeMem label' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::new_from_stock_action +-- method type : Constructor +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuAction stock action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new_from_stock_action" webkit_context_menu_item_new_from_stock_action :: + CUInt -> -- action : TInterface (Name {namespace = "WebKit2", name = "ContextMenuAction"}) + IO (Ptr ContextMenuItem) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' for the given stock action. +Stock actions are handled automatically by WebKit so that, for example, +when a menu item created with a 'GI.WebKit2.Enums.ContextMenuActionStop' is +activated the action associated will be handled by WebKit and the current +load operation will be stopped. You can get the 'GI.Gtk.Objects.Action.Action' of a +'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' created with a 'GI.WebKit2.Enums.ContextMenuAction' with +'GI.WebKit2.Objects.ContextMenuItem.contextMenuItemGetAction' and connect to 'GI.Gtk.Objects.Action.Action'::@/activate/@ signal +to be notified when the item is activated. But you can\'t prevent the associated +action from being performed. +-} +contextMenuItemNewFromStockAction :: + (B.CallStack.HasCallStack, MonadIO m) => + WebKit2.Enums.ContextMenuAction + {- ^ /@action@/: a 'GI.WebKit2.Enums.ContextMenuAction' stock action -} + -> m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNewFromStockAction action = liftIO $ do + let action' = (fromIntegral . fromEnum) action + result <- webkit_context_menu_item_new_from_stock_action action' + checkUnexpectedReturnNULL "contextMenuItemNewFromStockAction" result + result' <- (newObject ContextMenuItem) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::new_from_stock_action_with_label +-- method type : Constructor +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuAction stock action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a custom label text to use instead of the predefined one", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new_from_stock_action_with_label" webkit_context_menu_item_new_from_stock_action_with_label :: + CUInt -> -- action : TInterface (Name {namespace = "WebKit2", name = "ContextMenuAction"}) + CString -> -- label : TBasicType TUTF8 + IO (Ptr ContextMenuItem) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' for the given stock action using the given /@label@/. +Stock actions have a predefined label, this method can be used to create a +'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' for a 'GI.WebKit2.Enums.ContextMenuAction' but using a custom label. +-} +contextMenuItemNewFromStockActionWithLabel :: + (B.CallStack.HasCallStack, MonadIO m) => + WebKit2.Enums.ContextMenuAction + {- ^ /@action@/: a 'GI.WebKit2.Enums.ContextMenuAction' stock action -} + -> T.Text + {- ^ /@label@/: a custom label text to use instead of the predefined one -} + -> m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNewFromStockActionWithLabel action label = liftIO $ do + let action' = (fromIntegral . fromEnum) action + label' <- textToCString label + result <- webkit_context_menu_item_new_from_stock_action_with_label action' label' + checkUnexpectedReturnNULL "contextMenuItemNewFromStockActionWithLabel" result + result' <- (newObject ContextMenuItem) result + freeMem label' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::new_separator +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new_separator" webkit_context_menu_item_new_separator :: + IO (Ptr ContextMenuItem) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' representing a separator. +-} +contextMenuItemNewSeparator :: + (B.CallStack.HasCallStack, MonadIO m) => + m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNewSeparator = liftIO $ do + result <- webkit_context_menu_item_new_separator + checkUnexpectedReturnNULL "contextMenuItemNewSeparator" result + result' <- (newObject ContextMenuItem) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::new_with_submenu +-- method type : Constructor +-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the menu item label text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "submenu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_new_with_submenu" webkit_context_menu_item_new_with_submenu :: + CString -> -- label : TBasicType TUTF8 + Ptr WebKit2.ContextMenu.ContextMenu -> -- submenu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO (Ptr ContextMenuItem) + +{- | +Creates a new 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' using the given /@label@/ with a submenu. +-} +contextMenuItemNewWithSubmenu :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.ContextMenu.IsContextMenu a) => + T.Text + {- ^ /@label@/: the menu item label text -} + -> a + {- ^ /@submenu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' to set -} + -> m ContextMenuItem + {- ^ __Returns:__ the newly created 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' object. -} +contextMenuItemNewWithSubmenu label submenu = liftIO $ do + label' <- textToCString label + submenu' <- unsafeManagedPtrCastPtr submenu + result <- webkit_context_menu_item_new_with_submenu label' submenu' + checkUnexpectedReturnNULL "contextMenuItemNewWithSubmenu" result + result' <- (newObject ContextMenuItem) result + touchManagedPtr submenu + freeMem label' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ContextMenuItem::get_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_get_action" webkit_context_menu_item_get_action :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO (Ptr Gtk.Action.Action) + +{-# DEPRECATED contextMenuItemGetAction ["(Since version 2.18)","Use 'GI.WebKit2.Objects.ContextMenuItem.contextMenuItemGetGaction' instead."] #-} +{- | +Gets the action associated to /@item@/ as a 'GI.Gtk.Objects.Action.Action'. +-} +contextMenuItemGetAction :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m (Maybe Gtk.Action.Action) + {- ^ __Returns:__ the 'GI.Gtk.Objects.Action.Action' associated to the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem', + or 'Nothing' if /@item@/ is a separator. -} +contextMenuItemGetAction item = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + result <- webkit_context_menu_item_get_action item' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.Action.Action) result' + return result'' + touchManagedPtr item + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuItemGetActionMethodInfo +instance (signature ~ (m (Maybe Gtk.Action.Action)), MonadIO m, IsContextMenuItem a) => O.MethodInfo ContextMenuItemGetActionMethodInfo a signature where + overloadedMethod _ = contextMenuItemGetAction + +#endif + +-- method ContextMenuItem::get_gaction +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_get_gaction" webkit_context_menu_item_get_gaction :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO (Ptr Gio.Action.Action) + +{- | +Gets the action associated to /@item@/ as a 'GI.Gio.Interfaces.Action.Action'. + +/Since: 2.18/ +-} +contextMenuItemGetGaction :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m (Maybe Gio.Action.Action) + {- ^ __Returns:__ the 'GI.Gio.Interfaces.Action.Action' associated to the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem', + or 'Nothing' if /@item@/ is a separator. -} +contextMenuItemGetGaction item = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + result <- webkit_context_menu_item_get_gaction item' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gio.Action.Action) result' + return result'' + touchManagedPtr item + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuItemGetGactionMethodInfo +instance (signature ~ (m (Maybe Gio.Action.Action)), MonadIO m, IsContextMenuItem a) => O.MethodInfo ContextMenuItemGetGactionMethodInfo a signature where + overloadedMethod _ = contextMenuItemGetGaction + +#endif + +-- method ContextMenuItem::get_stock_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenuAction"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_get_stock_action" webkit_context_menu_item_get_stock_action :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO CUInt + +{- | +Gets the 'GI.WebKit2.Enums.ContextMenuAction' of /@item@/. If the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' was not +created for a stock action 'GI.WebKit2.Enums.ContextMenuActionCustom' will be +returned. If the 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' is a separator 'GI.WebKit2.Enums.ContextMenuActionNoAction' +will be returned. +-} +contextMenuItemGetStockAction :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m WebKit2.Enums.ContextMenuAction + {- ^ __Returns:__ the 'GI.WebKit2.Enums.ContextMenuAction' of /@item@/ -} +contextMenuItemGetStockAction item = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + result <- webkit_context_menu_item_get_stock_action item' + let result' = (toEnum . fromIntegral) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data ContextMenuItemGetStockActionMethodInfo +instance (signature ~ (m WebKit2.Enums.ContextMenuAction), MonadIO m, IsContextMenuItem a) => O.MethodInfo ContextMenuItemGetStockActionMethodInfo a signature where + overloadedMethod _ = contextMenuItemGetStockAction + +#endif + +-- method ContextMenuItem::get_submenu +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ContextMenu"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_get_submenu" webkit_context_menu_item_get_submenu :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO (Ptr WebKit2.ContextMenu.ContextMenu) + +{- | +Gets the submenu of /@item@/. +-} +contextMenuItemGetSubmenu :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m (Maybe WebKit2.ContextMenu.ContextMenu) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.ContextMenu.ContextMenu' representing the submenu of + /@item@/ or 'Nothing' if /@item@/ doesn\'t have a submenu. -} +contextMenuItemGetSubmenu item = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + result <- webkit_context_menu_item_get_submenu item' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.ContextMenu.ContextMenu) result' + return result'' + touchManagedPtr item + return maybeResult + +#if ENABLE_OVERLOADING +data ContextMenuItemGetSubmenuMethodInfo +instance (signature ~ (m (Maybe WebKit2.ContextMenu.ContextMenu)), MonadIO m, IsContextMenuItem a) => O.MethodInfo ContextMenuItemGetSubmenuMethodInfo a signature where + overloadedMethod _ = contextMenuItemGetSubmenu + +#endif + +-- method ContextMenuItem::is_separator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_is_separator" webkit_context_menu_item_is_separator :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + IO CInt + +{- | +Checks whether /@item@/ is a separator. +-} +contextMenuItemIsSeparator :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> m Bool + {- ^ __Returns:__ 'True' is /@item@/ is a separator or 'False' otherwise -} +contextMenuItemIsSeparator item = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + result <- webkit_context_menu_item_is_separator item' + let result' = (/= 0) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data ContextMenuItemIsSeparatorMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsContextMenuItem a) => O.MethodInfo ContextMenuItemIsSeparatorMethodInfo a signature where + overloadedMethod _ = contextMenuItemIsSeparator + +#endif + +-- method ContextMenuItem::set_submenu +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "submenu", argType = TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #WebKitContextMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_context_menu_item_set_submenu" webkit_context_menu_item_set_submenu :: + Ptr ContextMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "ContextMenuItem"}) + Ptr WebKit2.ContextMenu.ContextMenu -> -- submenu : TInterface (Name {namespace = "WebKit2", name = "ContextMenu"}) + IO () + +{- | +Sets or replaces the /@item@/ submenu. If /@submenu@/ is 'Nothing' the current +submenu of /@item@/ is removed. +-} +contextMenuItemSetSubmenu :: + (B.CallStack.HasCallStack, MonadIO m, IsContextMenuItem a, WebKit2.ContextMenu.IsContextMenu b) => + a + {- ^ /@item@/: a 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem' -} + -> Maybe (b) + {- ^ /@submenu@/: a 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> m () +contextMenuItemSetSubmenu item submenu = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeSubmenu <- case submenu of + Nothing -> return nullPtr + Just jSubmenu -> do + jSubmenu' <- unsafeManagedPtrCastPtr jSubmenu + return jSubmenu' + webkit_context_menu_item_set_submenu item' maybeSubmenu + touchManagedPtr item + whenJust submenu touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data ContextMenuItemSetSubmenuMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsContextMenuItem a, WebKit2.ContextMenu.IsContextMenu b) => O.MethodInfo ContextMenuItemSetSubmenuMethodInfo a signature where + overloadedMethod _ = contextMenuItemSetSubmenu + +#endif + + diff --git a/GI/WebKit2/Objects/ContextMenuItem.hs-boot b/GI/WebKit2/Objects/ContextMenuItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ContextMenuItem.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.ContextMenuItem 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 + +newtype ContextMenuItem = ContextMenuItem (ManagedPtr ContextMenuItem) +instance GObject ContextMenuItem where +class (GObject o, O.IsDescendantOf ContextMenuItem o) => IsContextMenuItem o +instance (GObject o, O.IsDescendantOf ContextMenuItem o) => IsContextMenuItem o +instance O.HasParentTypes ContextMenuItem +#if ENABLE_OVERLOADING +data ContextMenuItemGetActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuItemGetGactionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuItemGetStockActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuItemGetSubmenuMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuItemIsSeparatorMethodInfo +#endif +#if ENABLE_OVERLOADING +data ContextMenuItemSetSubmenuMethodInfo +#endif diff --git a/GI/WebKit2/Objects/CookieManager.hs b/GI/WebKit2/Objects/CookieManager.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/CookieManager.hs @@ -0,0 +1,1054 @@ + + +{- | +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.CookieManager + ( + +-- * Exported types + CookieManager(..) , + IsCookieManager , + toCookieManager , + noCookieManager , + + + -- * Methods +-- ** addCookie #method:addCookie# + +#if ENABLE_OVERLOADING + CookieManagerAddCookieMethodInfo , +#endif + cookieManagerAddCookie , + + +-- ** addCookieFinish #method:addCookieFinish# + +#if ENABLE_OVERLOADING + CookieManagerAddCookieFinishMethodInfo , +#endif + cookieManagerAddCookieFinish , + + +-- ** deleteAllCookies #method:deleteAllCookies# + +#if ENABLE_OVERLOADING + CookieManagerDeleteAllCookiesMethodInfo , +#endif + cookieManagerDeleteAllCookies , + + +-- ** deleteCookie #method:deleteCookie# + +#if ENABLE_OVERLOADING + CookieManagerDeleteCookieMethodInfo , +#endif + cookieManagerDeleteCookie , + + +-- ** deleteCookieFinish #method:deleteCookieFinish# + +#if ENABLE_OVERLOADING + CookieManagerDeleteCookieFinishMethodInfo, +#endif + cookieManagerDeleteCookieFinish , + + +-- ** deleteCookiesForDomain #method:deleteCookiesForDomain# + +#if ENABLE_OVERLOADING + CookieManagerDeleteCookiesForDomainMethodInfo, +#endif + cookieManagerDeleteCookiesForDomain , + + +-- ** getAcceptPolicy #method:getAcceptPolicy# + +#if ENABLE_OVERLOADING + CookieManagerGetAcceptPolicyMethodInfo , +#endif + cookieManagerGetAcceptPolicy , + + +-- ** getAcceptPolicyFinish #method:getAcceptPolicyFinish# + +#if ENABLE_OVERLOADING + CookieManagerGetAcceptPolicyFinishMethodInfo, +#endif + cookieManagerGetAcceptPolicyFinish , + + +-- ** getCookies #method:getCookies# + +#if ENABLE_OVERLOADING + CookieManagerGetCookiesMethodInfo , +#endif + cookieManagerGetCookies , + + +-- ** getCookiesFinish #method:getCookiesFinish# + +#if ENABLE_OVERLOADING + CookieManagerGetCookiesFinishMethodInfo , +#endif + cookieManagerGetCookiesFinish , + + +-- ** getDomainsWithCookies #method:getDomainsWithCookies# + +#if ENABLE_OVERLOADING + CookieManagerGetDomainsWithCookiesMethodInfo, +#endif + cookieManagerGetDomainsWithCookies , + + +-- ** getDomainsWithCookiesFinish #method:getDomainsWithCookiesFinish# + +#if ENABLE_OVERLOADING + CookieManagerGetDomainsWithCookiesFinishMethodInfo, +#endif + cookieManagerGetDomainsWithCookiesFinish, + + +-- ** setAcceptPolicy #method:setAcceptPolicy# + +#if ENABLE_OVERLOADING + CookieManagerSetAcceptPolicyMethodInfo , +#endif + cookieManagerSetAcceptPolicy , + + +-- ** setPersistentStorage #method:setPersistentStorage# + +#if ENABLE_OVERLOADING + CookieManagerSetPersistentStorageMethodInfo, +#endif + cookieManagerSetPersistentStorage , + + + + + -- * Signals +-- ** changed #signal:changed# + + C_CookieManagerChangedCallback , + CookieManagerChangedCallback , +#if ENABLE_OVERLOADING + CookieManagerChangedSignalInfo , +#endif + afterCookieManagerChanged , + genClosure_CookieManagerChanged , + mk_CookieManagerChangedCallback , + noCookieManagerChangedCallback , + onCookieManagerChanged , + wrap_CookieManagerChangedCallback , + + + + + ) 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.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Soup.Structs.Cookie as Soup.Cookie +import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype CookieManager = CookieManager (ManagedPtr CookieManager) +foreign import ccall "webkit_cookie_manager_get_type" + c_webkit_cookie_manager_get_type :: IO GType + +instance GObject CookieManager where + gobjectType = c_webkit_cookie_manager_get_type + + +-- | Type class for types which can be safely cast to `CookieManager`, for instance with `toCookieManager`. +class (GObject o, O.IsDescendantOf CookieManager o) => IsCookieManager o +instance (GObject o, O.IsDescendantOf CookieManager o) => IsCookieManager o + +instance O.HasParentTypes CookieManager +type instance O.ParentTypes CookieManager = '[GObject.Object.Object] + +-- | Cast to `CookieManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCookieManager :: (MonadIO m, IsCookieManager o) => o -> m CookieManager +toCookieManager = liftIO . unsafeCastTo CookieManager + +-- | A convenience alias for `Nothing` :: `Maybe` `CookieManager`. +noCookieManager :: Maybe CookieManager +noCookieManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCookieManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveCookieManagerMethod "addCookie" o = CookieManagerAddCookieMethodInfo + ResolveCookieManagerMethod "addCookieFinish" o = CookieManagerAddCookieFinishMethodInfo + ResolveCookieManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCookieManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCookieManagerMethod "deleteAllCookies" o = CookieManagerDeleteAllCookiesMethodInfo + ResolveCookieManagerMethod "deleteCookie" o = CookieManagerDeleteCookieMethodInfo + ResolveCookieManagerMethod "deleteCookieFinish" o = CookieManagerDeleteCookieFinishMethodInfo + ResolveCookieManagerMethod "deleteCookiesForDomain" o = CookieManagerDeleteCookiesForDomainMethodInfo + ResolveCookieManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCookieManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCookieManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCookieManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCookieManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCookieManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCookieManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCookieManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCookieManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCookieManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCookieManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCookieManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCookieManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCookieManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCookieManagerMethod "getAcceptPolicy" o = CookieManagerGetAcceptPolicyMethodInfo + ResolveCookieManagerMethod "getAcceptPolicyFinish" o = CookieManagerGetAcceptPolicyFinishMethodInfo + ResolveCookieManagerMethod "getCookies" o = CookieManagerGetCookiesMethodInfo + ResolveCookieManagerMethod "getCookiesFinish" o = CookieManagerGetCookiesFinishMethodInfo + ResolveCookieManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCookieManagerMethod "getDomainsWithCookies" o = CookieManagerGetDomainsWithCookiesMethodInfo + ResolveCookieManagerMethod "getDomainsWithCookiesFinish" o = CookieManagerGetDomainsWithCookiesFinishMethodInfo + ResolveCookieManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCookieManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCookieManagerMethod "setAcceptPolicy" o = CookieManagerSetAcceptPolicyMethodInfo + ResolveCookieManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCookieManagerMethod "setPersistentStorage" o = CookieManagerSetPersistentStorageMethodInfo + ResolveCookieManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCookieManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCookieManagerMethod t CookieManager, O.MethodInfo info CookieManager p) => OL.IsLabel t (CookieManager -> 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 CookieManager::changed +{- | +This signal is emitted when cookies are added, removed or modified. +-} +type CookieManagerChangedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CookieManagerChangedCallback`@. +noCookieManagerChangedCallback :: Maybe CookieManagerChangedCallback +noCookieManagerChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CookieManagerChangedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CookieManagerChangedCallback`. +foreign import ccall "wrapper" + mk_CookieManagerChangedCallback :: C_CookieManagerChangedCallback -> IO (FunPtr C_CookieManagerChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CookieManagerChanged :: MonadIO m => CookieManagerChangedCallback -> m (GClosure C_CookieManagerChangedCallback) +genClosure_CookieManagerChanged cb = liftIO $ do + let cb' = wrap_CookieManagerChangedCallback cb + mk_CookieManagerChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CookieManagerChangedCallback` into a `C_CookieManagerChangedCallback`. +wrap_CookieManagerChangedCallback :: + CookieManagerChangedCallback -> + C_CookieManagerChangedCallback +wrap_CookieManagerChangedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' cookieManager #changed callback +@ +-} +onCookieManagerChanged :: (IsCookieManager a, MonadIO m) => a -> CookieManagerChangedCallback -> m SignalHandlerId +onCookieManagerChanged obj cb = liftIO $ do + let cb' = wrap_CookieManagerChangedCallback cb + cb'' <- mk_CookieManagerChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' cookieManager #changed callback +@ +-} +afterCookieManagerChanged :: (IsCookieManager a, MonadIO m) => a -> CookieManagerChangedCallback -> m SignalHandlerId +afterCookieManagerChanged obj cb = liftIO $ do + let cb' = wrap_CookieManagerChangedCallback cb + cb'' <- mk_CookieManagerChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CookieManager +type instance O.AttributeList CookieManager = CookieManagerAttributeList +type CookieManagerAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data CookieManagerChangedSignalInfo +instance SignalInfo CookieManagerChangedSignalInfo where + type HaskellCallbackType CookieManagerChangedSignalInfo = CookieManagerChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CookieManagerChangedCallback cb + cb'' <- mk_CookieManagerChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' connectMode + +type instance O.SignalList CookieManager = CookieManagerSignalList +type CookieManagerSignalList = ('[ '("changed", CookieManagerChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CookieManager::add_cookie +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TInterface (Name {namespace = "Soup", name = "Cookie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupCookie to be added", 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 = 4, 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_cookie_manager_add_cookie" webkit_cookie_manager_add_cookie :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Soup.Cookie.Cookie -> -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"}) + 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 add a 'GI.Soup.Structs.Cookie.Cookie' to the underlying storage. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.CookieManager.cookieManagerAddCookieFinish' to get the result of the operation. + +/Since: 2.20/ +-} +cookieManagerAddCookie :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> Soup.Cookie.Cookie + {- ^ /@cookie@/: the 'GI.Soup.Structs.Cookie.Cookie' to be added -} + -> 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 () +cookieManagerAddCookie cookieManager cookie cancellable callback = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + cookie' <- unsafeManagedPtrGetPtr cookie + 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_cookie_manager_add_cookie cookieManager' cookie' maybeCancellable maybeCallback userData + touchManagedPtr cookieManager + touchManagedPtr cookie + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CookieManagerAddCookieMethodInfo +instance (signature ~ (Soup.Cookie.Cookie -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CookieManagerAddCookieMethodInfo a signature where + overloadedMethod _ = cookieManagerAddCookie + +#endif + +-- method CookieManager::add_cookie_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_add_cookie_finish" webkit_cookie_manager_add_cookie_finish :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.CookieManager.cookieManagerAddCookie'. + +/Since: 2.20/ +-} +cookieManagerAddCookieFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +cookieManagerAddCookieFinish cookieManager result_ = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_cookie_manager_add_cookie_finish cookieManager' result_' + touchManagedPtr cookieManager + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CookieManagerAddCookieFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CookieManagerAddCookieFinishMethodInfo a signature where + overloadedMethod _ = cookieManagerAddCookieFinish + +#endif + +-- method CookieManager::delete_all_cookies +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_delete_all_cookies" webkit_cookie_manager_delete_all_cookies :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + IO () + +{-# DEPRECATED cookieManagerDeleteAllCookies ["(Since version 2.16)","Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear' instead."] #-} +{- | +Delete all cookies of /@cookieManager@/ +-} +cookieManagerDeleteAllCookies :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> m () +cookieManagerDeleteAllCookies cookieManager = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + webkit_cookie_manager_delete_all_cookies cookieManager' + touchManagedPtr cookieManager + return () + +#if ENABLE_OVERLOADING +data CookieManagerDeleteAllCookiesMethodInfo +instance (signature ~ (m ()), MonadIO m, IsCookieManager a) => O.MethodInfo CookieManagerDeleteAllCookiesMethodInfo a signature where + overloadedMethod _ = cookieManagerDeleteAllCookies + +#endif + +-- method CookieManager::delete_cookie +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TInterface (Name {namespace = "Soup", name = "Cookie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupCookie to be deleted", 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 = 4, 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_cookie_manager_delete_cookie" webkit_cookie_manager_delete_cookie :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Soup.Cookie.Cookie -> -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"}) + 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 delete a 'GI.Soup.Structs.Cookie.Cookie' from the current session. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.CookieManager.cookieManagerDeleteCookieFinish' to get the result of the operation. + +/Since: 2.20/ +-} +cookieManagerDeleteCookie :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> Soup.Cookie.Cookie + {- ^ /@cookie@/: the 'GI.Soup.Structs.Cookie.Cookie' to be deleted -} + -> 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 () +cookieManagerDeleteCookie cookieManager cookie cancellable callback = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + cookie' <- unsafeManagedPtrGetPtr cookie + 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_cookie_manager_delete_cookie cookieManager' cookie' maybeCancellable maybeCallback userData + touchManagedPtr cookieManager + touchManagedPtr cookie + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookieMethodInfo +instance (signature ~ (Soup.Cookie.Cookie -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CookieManagerDeleteCookieMethodInfo a signature where + overloadedMethod _ = cookieManagerDeleteCookie + +#endif + +-- method CookieManager::delete_cookie_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_delete_cookie_finish" webkit_cookie_manager_delete_cookie_finish :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.CookieManager.cookieManagerDeleteCookie'. + +/Since: 2.20/ +-} +cookieManagerDeleteCookieFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +cookieManagerDeleteCookieFinish cookieManager result_ = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_cookie_manager_delete_cookie_finish cookieManager' result_' + touchManagedPtr cookieManager + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookieFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CookieManagerDeleteCookieFinishMethodInfo a signature where + overloadedMethod _ = cookieManagerDeleteCookieFinish + +#endif + +-- method CookieManager::delete_cookies_for_domain +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a domain name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_delete_cookies_for_domain" webkit_cookie_manager_delete_cookies_for_domain :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + CString -> -- domain : TBasicType TUTF8 + IO () + +{-# DEPRECATED cookieManagerDeleteCookiesForDomain ["(Since version 2.16)","Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemove' instead."] #-} +{- | +Remove all cookies of /@cookieManager@/ for the given /@domain@/. +-} +cookieManagerDeleteCookiesForDomain :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> T.Text + {- ^ /@domain@/: a domain name -} + -> m () +cookieManagerDeleteCookiesForDomain cookieManager domain = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + domain' <- textToCString domain + webkit_cookie_manager_delete_cookies_for_domain cookieManager' domain' + touchManagedPtr cookieManager + freeMem domain' + return () + +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookiesForDomainMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsCookieManager a) => O.MethodInfo CookieManagerDeleteCookiesForDomainMethodInfo a signature where + overloadedMethod _ = cookieManagerDeleteCookiesForDomain + +#endif + +-- method CookieManager::get_accept_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", 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_cookie_manager_get_accept_policy" webkit_cookie_manager_get_accept_policy :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + 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 cookie acceptance policy of /@cookieManager@/. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.CookieManager.cookieManagerGetAcceptPolicyFinish' to get the result of the operation. +-} +cookieManagerGetAcceptPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> 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 () +cookieManagerGetAcceptPolicy cookieManager cancellable callback = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + 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_cookie_manager_get_accept_policy cookieManager' maybeCancellable maybeCallback userData + touchManagedPtr cookieManager + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CookieManagerGetAcceptPolicyMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CookieManagerGetAcceptPolicyMethodInfo a signature where + overloadedMethod _ = cookieManagerGetAcceptPolicy + +#endif + +-- method CookieManager::get_accept_policy_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CookieAcceptPolicy"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_get_accept_policy_finish" webkit_cookie_manager_get_accept_policy_finish :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CUInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.CookieManager.cookieManagerGetAcceptPolicy'. +-} +cookieManagerGetAcceptPolicyFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.Enums.CookieAcceptPolicy + {- ^ __Returns:__ the cookie acceptance policy of /@cookieManager@/ as a 'GI.WebKit2.Enums.CookieAcceptPolicy'. /(Can throw 'Data.GI.Base.GError.GError')/ -} +cookieManagerGetAcceptPolicyFinish cookieManager result_ = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_cookie_manager_get_accept_policy_finish cookieManager' result_' + let result' = (toEnum . fromIntegral) result + touchManagedPtr cookieManager + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CookieManagerGetAcceptPolicyFinishMethodInfo +instance (signature ~ (b -> m WebKit2.Enums.CookieAcceptPolicy), MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CookieManagerGetAcceptPolicyFinishMethodInfo a signature where + overloadedMethod _ = cookieManagerGetAcceptPolicyFinish + +#endif + +-- method CookieManager::get_cookies +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", 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 associated to the cookies to be retrieved", 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 = 4, 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_cookie_manager_get_cookies" webkit_cookie_manager_get_cookies :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + CString -> -- uri : TBasicType TUTF8 + 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 a list of 'GI.Soup.Structs.Cookie.Cookie' from /@cookieManager@/ associated with /@uri@/, which +must be either an HTTP or an HTTPS URL. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.CookieManager.cookieManagerGetCookiesFinish' to get the result of the operation. + +/Since: 2.20/ +-} +cookieManagerGetCookies :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> T.Text + {- ^ /@uri@/: the URI associated to the cookies to be retrieved -} + -> 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 () +cookieManagerGetCookies cookieManager uri cancellable callback = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + uri' <- textToCString uri + 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_cookie_manager_get_cookies cookieManager' uri' maybeCancellable maybeCallback userData + touchManagedPtr cookieManager + whenJust cancellable touchManagedPtr + freeMem uri' + return () + +#if ENABLE_OVERLOADING +data CookieManagerGetCookiesMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CookieManagerGetCookiesMethodInfo a signature where + overloadedMethod _ = cookieManagerGetCookies + +#endif + +-- method CookieManager::get_cookies_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Soup", name = "Cookie"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_get_cookies_finish" webkit_cookie_manager_get_cookies_finish :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (GList (Ptr Soup.Cookie.Cookie))) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.CookieManager.cookieManagerGetCookies'. +The return value is a 'GI.GLib.Structs.SList.SList' of 'GI.Soup.Structs.Cookie.Cookie' instances which should be released +with @/g_list_free_full()/@ and 'GI.Soup.Structs.Cookie.cookieFree'. + +/Since: 2.20/ +-} +cookieManagerGetCookiesFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m [Soup.Cookie.Cookie] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Soup.Structs.Cookie.Cookie' instances. /(Can throw 'Data.GI.Base.GError.GError')/ -} +cookieManagerGetCookiesFinish cookieManager result_ = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_cookie_manager_get_cookies_finish cookieManager' result_' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Soup.Cookie.Cookie) result' + g_list_free result + touchManagedPtr cookieManager + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CookieManagerGetCookiesFinishMethodInfo +instance (signature ~ (b -> m [Soup.Cookie.Cookie]), MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CookieManagerGetCookiesFinishMethodInfo a signature where + overloadedMethod _ = cookieManagerGetCookiesFinish + +#endif + +-- method CookieManager::get_domains_with_cookies +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", 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_cookie_manager_get_domains_with_cookies" webkit_cookie_manager_get_domains_with_cookies :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + 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 () + +{-# DEPRECATED cookieManagerGetDomainsWithCookies ["(Since version 2.16)","Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetch' instead."] #-} +{- | +Asynchronously get the list of domains for which /@cookieManager@/ contains cookies. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.CookieManager.cookieManagerGetDomainsWithCookiesFinish' to get the result of the operation. +-} +cookieManagerGetDomainsWithCookies :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> 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 () +cookieManagerGetDomainsWithCookies cookieManager cancellable callback = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + 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_cookie_manager_get_domains_with_cookies cookieManager' maybeCancellable maybeCallback userData + touchManagedPtr cookieManager + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CookieManagerGetDomainsWithCookiesMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCookieManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo CookieManagerGetDomainsWithCookiesMethodInfo a signature where + overloadedMethod _ = cookieManagerGetDomainsWithCookies + +#endif + +-- method CookieManager::get_domains_with_cookies_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_get_domains_with_cookies_finish" webkit_cookie_manager_get_domains_with_cookies_finish :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr CString) + +{-# DEPRECATED cookieManagerGetDomainsWithCookiesFinish ["(Since version 2.16)","Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetchFinish' instead."] #-} +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.CookieManager.cookieManagerGetDomainsWithCookies'. +The return value is a 'Nothing' terminated list of strings which should +be released with 'GI.GLib.Functions.strfreev'. +-} +cookieManagerGetDomainsWithCookiesFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m [T.Text] + {- ^ __Returns:__ A 'Nothing' terminated array of domain names + or 'Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +cookieManagerGetDomainsWithCookiesFinish cookieManager result_ = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_cookie_manager_get_domains_with_cookies_finish cookieManager' result_' + checkUnexpectedReturnNULL "cookieManagerGetDomainsWithCookiesFinish" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr cookieManager + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CookieManagerGetDomainsWithCookiesFinishMethodInfo +instance (signature ~ (b -> m [T.Text]), MonadIO m, IsCookieManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo CookieManagerGetDomainsWithCookiesFinishMethodInfo a signature where + overloadedMethod _ = cookieManagerGetDomainsWithCookiesFinish + +#endif + +-- method CookieManager::set_accept_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "policy", argType = TInterface (Name {namespace = "WebKit2", name = "CookieAcceptPolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieAcceptPolicy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_set_accept_policy" webkit_cookie_manager_set_accept_policy :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + CUInt -> -- policy : TInterface (Name {namespace = "WebKit2", name = "CookieAcceptPolicy"}) + IO () + +{- | +Set the cookie acceptance policy of /@cookieManager@/ as /@policy@/. +-} +cookieManagerSetAcceptPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> WebKit2.Enums.CookieAcceptPolicy + {- ^ /@policy@/: a 'GI.WebKit2.Enums.CookieAcceptPolicy' -} + -> m () +cookieManagerSetAcceptPolicy cookieManager policy = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + let policy' = (fromIntegral . fromEnum) policy + webkit_cookie_manager_set_accept_policy cookieManager' policy' + touchManagedPtr cookieManager + return () + +#if ENABLE_OVERLOADING +data CookieManagerSetAcceptPolicyMethodInfo +instance (signature ~ (WebKit2.Enums.CookieAcceptPolicy -> m ()), MonadIO m, IsCookieManager a) => O.MethodInfo CookieManagerSetAcceptPolicyMethodInfo a signature where + overloadedMethod _ = cookieManagerSetAcceptPolicy + +#endif + +-- method CookieManager::set_persistent_storage +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cookie_manager", argType = TInterface (Name {namespace = "WebKit2", name = "CookieManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookieManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the filename to read to/write from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "storage", argType = TInterface (Name {namespace = "WebKit2", name = "CookiePersistentStorage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCookiePersistentStorage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_cookie_manager_set_persistent_storage" webkit_cookie_manager_set_persistent_storage :: + Ptr CookieManager -> -- cookie_manager : TInterface (Name {namespace = "WebKit2", name = "CookieManager"}) + CString -> -- filename : TBasicType TUTF8 + CUInt -> -- storage : TInterface (Name {namespace = "WebKit2", name = "CookiePersistentStorage"}) + IO () + +{- | +Set the /@filename@/ where non-session cookies are stored persistently using +/@storage@/ as the format to read\/write the cookies. +Cookies are initially read from /@filename@/ to create an initial set of cookies. +Then, non-session cookies will be written to /@filename@/ when the WebKitCookieManager::changed +signal is emitted. +By default, /@cookieManager@/ doesn\'t store the cookies persistently, so you need to call this +method to keep cookies saved across sessions. + +This method should never be called on a 'GI.WebKit2.Objects.CookieManager.CookieManager' associated to an ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. +-} +cookieManagerSetPersistentStorage :: + (B.CallStack.HasCallStack, MonadIO m, IsCookieManager a) => + a + {- ^ /@cookieManager@/: a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} + -> T.Text + {- ^ /@filename@/: the filename to read to\/write from -} + -> WebKit2.Enums.CookiePersistentStorage + {- ^ /@storage@/: a 'GI.WebKit2.Enums.CookiePersistentStorage' -} + -> m () +cookieManagerSetPersistentStorage cookieManager filename storage = liftIO $ do + cookieManager' <- unsafeManagedPtrCastPtr cookieManager + filename' <- textToCString filename + let storage' = (fromIntegral . fromEnum) storage + webkit_cookie_manager_set_persistent_storage cookieManager' filename' storage' + touchManagedPtr cookieManager + freeMem filename' + return () + +#if ENABLE_OVERLOADING +data CookieManagerSetPersistentStorageMethodInfo +instance (signature ~ (T.Text -> WebKit2.Enums.CookiePersistentStorage -> m ()), MonadIO m, IsCookieManager a) => O.MethodInfo CookieManagerSetPersistentStorageMethodInfo a signature where + overloadedMethod _ = cookieManagerSetPersistentStorage + +#endif + + diff --git a/GI/WebKit2/Objects/CookieManager.hs-boot b/GI/WebKit2/Objects/CookieManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/CookieManager.hs-boot @@ -0,0 +1,74 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.CookieManager 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 + +newtype CookieManager = CookieManager (ManagedPtr CookieManager) +instance GObject CookieManager where +class (GObject o, O.IsDescendantOf CookieManager o) => IsCookieManager o +instance (GObject o, O.IsDescendantOf CookieManager o) => IsCookieManager o +instance O.HasParentTypes CookieManager +#if ENABLE_OVERLOADING +data CookieManagerChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerAddCookieMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerAddCookieFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerDeleteAllCookiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookieMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookieFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerDeleteCookiesForDomainMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetAcceptPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetAcceptPolicyFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetCookiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetCookiesFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetDomainsWithCookiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerGetDomainsWithCookiesFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerSetAcceptPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data CookieManagerSetPersistentStorageMethodInfo +#endif diff --git a/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs b/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs @@ -0,0 +1,124 @@ + + +{- | +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.DeviceInfoPermissionRequest + ( + +-- * Exported types + DeviceInfoPermissionRequest(..) , + IsDeviceInfoPermissionRequest , + toDeviceInfoPermissionRequest , + noDeviceInfoPermissionRequest , + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest + +-- | Memory-managed wrapper type. +newtype DeviceInfoPermissionRequest = DeviceInfoPermissionRequest (ManagedPtr DeviceInfoPermissionRequest) +foreign import ccall "webkit_device_info_permission_request_get_type" + c_webkit_device_info_permission_request_get_type :: IO GType + +instance GObject DeviceInfoPermissionRequest where + gobjectType = c_webkit_device_info_permission_request_get_type + + +-- | Type class for types which can be safely cast to `DeviceInfoPermissionRequest`, for instance with `toDeviceInfoPermissionRequest`. +class (GObject o, O.IsDescendantOf DeviceInfoPermissionRequest o) => IsDeviceInfoPermissionRequest o +instance (GObject o, O.IsDescendantOf DeviceInfoPermissionRequest o) => IsDeviceInfoPermissionRequest o + +instance O.HasParentTypes DeviceInfoPermissionRequest +type instance O.ParentTypes DeviceInfoPermissionRequest = '[GObject.Object.Object, WebKit2.PermissionRequest.PermissionRequest] + +-- | Cast to `DeviceInfoPermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDeviceInfoPermissionRequest :: (MonadIO m, IsDeviceInfoPermissionRequest o) => o -> m DeviceInfoPermissionRequest +toDeviceInfoPermissionRequest = liftIO . unsafeCastTo DeviceInfoPermissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `DeviceInfoPermissionRequest`. +noDeviceInfoPermissionRequest :: Maybe DeviceInfoPermissionRequest +noDeviceInfoPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDeviceInfoPermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveDeviceInfoPermissionRequestMethod "allow" o = WebKit2.PermissionRequest.PermissionRequestAllowMethodInfo + ResolveDeviceInfoPermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDeviceInfoPermissionRequestMethod "deny" o = WebKit2.PermissionRequest.PermissionRequestDenyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDeviceInfoPermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDeviceInfoPermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDeviceInfoPermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDeviceInfoPermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDeviceInfoPermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDeviceInfoPermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDeviceInfoPermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDeviceInfoPermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDeviceInfoPermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDeviceInfoPermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDeviceInfoPermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDeviceInfoPermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDeviceInfoPermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDeviceInfoPermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDeviceInfoPermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDeviceInfoPermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDeviceInfoPermissionRequestMethod t DeviceInfoPermissionRequest, O.MethodInfo info DeviceInfoPermissionRequest p) => OL.IsLabel t (DeviceInfoPermissionRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList DeviceInfoPermissionRequest +type instance O.AttributeList DeviceInfoPermissionRequest = DeviceInfoPermissionRequestAttributeList +type DeviceInfoPermissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList DeviceInfoPermissionRequest = DeviceInfoPermissionRequestSignalList +type DeviceInfoPermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs-boot b/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/DeviceInfoPermissionRequest.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.DeviceInfoPermissionRequest 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 + +newtype DeviceInfoPermissionRequest = DeviceInfoPermissionRequest (ManagedPtr DeviceInfoPermissionRequest) +instance GObject DeviceInfoPermissionRequest where +class (GObject o, O.IsDescendantOf DeviceInfoPermissionRequest o) => IsDeviceInfoPermissionRequest o +instance (GObject o, O.IsDescendantOf DeviceInfoPermissionRequest o) => IsDeviceInfoPermissionRequest o +instance O.HasParentTypes DeviceInfoPermissionRequest diff --git a/GI/WebKit2/Objects/Download.hs b/GI/WebKit2/Objects/Download.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Download.hs @@ -0,0 +1,1347 @@ + + +{- | +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.Download + ( + +-- * Exported types + Download(..) , + IsDownload , + toDownload , + noDownload , + + + -- * Methods +-- ** cancel #method:cancel# + +#if ENABLE_OVERLOADING + DownloadCancelMethodInfo , +#endif + downloadCancel , + + +-- ** getAllowOverwrite #method:getAllowOverwrite# + +#if ENABLE_OVERLOADING + DownloadGetAllowOverwriteMethodInfo , +#endif + downloadGetAllowOverwrite , + + +-- ** getDestination #method:getDestination# + +#if ENABLE_OVERLOADING + DownloadGetDestinationMethodInfo , +#endif + downloadGetDestination , + + +-- ** getElapsedTime #method:getElapsedTime# + +#if ENABLE_OVERLOADING + DownloadGetElapsedTimeMethodInfo , +#endif + downloadGetElapsedTime , + + +-- ** getEstimatedProgress #method:getEstimatedProgress# + +#if ENABLE_OVERLOADING + DownloadGetEstimatedProgressMethodInfo , +#endif + downloadGetEstimatedProgress , + + +-- ** getReceivedDataLength #method:getReceivedDataLength# + +#if ENABLE_OVERLOADING + DownloadGetReceivedDataLengthMethodInfo , +#endif + downloadGetReceivedDataLength , + + +-- ** getRequest #method:getRequest# + +#if ENABLE_OVERLOADING + DownloadGetRequestMethodInfo , +#endif + downloadGetRequest , + + +-- ** getResponse #method:getResponse# + +#if ENABLE_OVERLOADING + DownloadGetResponseMethodInfo , +#endif + downloadGetResponse , + + +-- ** getWebView #method:getWebView# + +#if ENABLE_OVERLOADING + DownloadGetWebViewMethodInfo , +#endif + downloadGetWebView , + + +-- ** setAllowOverwrite #method:setAllowOverwrite# + +#if ENABLE_OVERLOADING + DownloadSetAllowOverwriteMethodInfo , +#endif + downloadSetAllowOverwrite , + + +-- ** setDestination #method:setDestination# + +#if ENABLE_OVERLOADING + DownloadSetDestinationMethodInfo , +#endif + downloadSetDestination , + + + + + -- * Properties +-- ** allowOverwrite #attr:allowOverwrite# +{- | Whether or not the download is allowed to overwrite an existing file on +disk. If this property is 'False' and the destination already exists, +the download will fail. + +/Since: 2.6/ +-} +#if ENABLE_OVERLOADING + DownloadAllowOverwritePropertyInfo , +#endif + constructDownloadAllowOverwrite , +#if ENABLE_OVERLOADING + downloadAllowOverwrite , +#endif + getDownloadAllowOverwrite , + setDownloadAllowOverwrite , + + +-- ** destination #attr:destination# +{- | The local URI to where the download will be saved. +-} +#if ENABLE_OVERLOADING + DownloadDestinationPropertyInfo , +#endif +#if ENABLE_OVERLOADING + downloadDestination , +#endif + getDownloadDestination , + + +-- ** estimatedProgress #attr:estimatedProgress# +{- | An estimate of the percent completion for the download operation. +This value will range from 0.0 to 1.0. The value is an estimate +based on the total number of bytes expected to be received for +a download. +If you need a more accurate progress information you can connect to +'GI.WebKit2.Objects.Download.Download'::@/received-data/@ signal to track the progress. +-} +#if ENABLE_OVERLOADING + DownloadEstimatedProgressPropertyInfo , +#endif +#if ENABLE_OVERLOADING + downloadEstimatedProgress , +#endif + getDownloadEstimatedProgress , + + +-- ** response #attr:response# +{- | The 'GI.WebKit2.Objects.URIResponse.URIResponse' associated with this download. +-} +#if ENABLE_OVERLOADING + DownloadResponsePropertyInfo , +#endif +#if ENABLE_OVERLOADING + downloadResponse , +#endif + getDownloadResponse , + + + + + -- * Signals +-- ** createdDestination #signal:createdDestination# + + C_DownloadCreatedDestinationCallback , + DownloadCreatedDestinationCallback , +#if ENABLE_OVERLOADING + DownloadCreatedDestinationSignalInfo , +#endif + afterDownloadCreatedDestination , + genClosure_DownloadCreatedDestination , + mk_DownloadCreatedDestinationCallback , + noDownloadCreatedDestinationCallback , + onDownloadCreatedDestination , + wrap_DownloadCreatedDestinationCallback , + + +-- ** decideDestination #signal:decideDestination# + + C_DownloadDecideDestinationCallback , + DownloadDecideDestinationCallback , +#if ENABLE_OVERLOADING + DownloadDecideDestinationSignalInfo , +#endif + afterDownloadDecideDestination , + genClosure_DownloadDecideDestination , + mk_DownloadDecideDestinationCallback , + noDownloadDecideDestinationCallback , + onDownloadDecideDestination , + wrap_DownloadDecideDestinationCallback , + + +-- ** failed #signal:failed# + + C_DownloadFailedCallback , + DownloadFailedCallback , +#if ENABLE_OVERLOADING + DownloadFailedSignalInfo , +#endif + afterDownloadFailed , + genClosure_DownloadFailed , + mk_DownloadFailedCallback , + noDownloadFailedCallback , + onDownloadFailed , + wrap_DownloadFailedCallback , + + +-- ** finished #signal:finished# + + C_DownloadFinishedCallback , + DownloadFinishedCallback , +#if ENABLE_OVERLOADING + DownloadFinishedSignalInfo , +#endif + afterDownloadFinished , + genClosure_DownloadFinished , + mk_DownloadFinishedCallback , + noDownloadFinishedCallback , + onDownloadFinished , + wrap_DownloadFinishedCallback , + + +-- ** receivedData #signal:receivedData# + + C_DownloadReceivedDataCallback , + DownloadReceivedDataCallback , +#if ENABLE_OVERLOADING + DownloadReceivedDataSignalInfo , +#endif + afterDownloadReceivedData , + genClosure_DownloadReceivedData , + mk_DownloadReceivedDataCallback , + noDownloadReceivedDataCallback , + onDownloadReceivedData , + wrap_DownloadReceivedDataCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIResponse as WebKit2.URIResponse +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView + +-- | Memory-managed wrapper type. +newtype Download = Download (ManagedPtr Download) +foreign import ccall "webkit_download_get_type" + c_webkit_download_get_type :: IO GType + +instance GObject Download where + gobjectType = c_webkit_download_get_type + + +-- | Type class for types which can be safely cast to `Download`, for instance with `toDownload`. +class (GObject o, O.IsDescendantOf Download o) => IsDownload o +instance (GObject o, O.IsDescendantOf Download o) => IsDownload o + +instance O.HasParentTypes Download +type instance O.ParentTypes Download = '[GObject.Object.Object] + +-- | Cast to `Download`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDownload :: (MonadIO m, IsDownload o) => o -> m Download +toDownload = liftIO . unsafeCastTo Download + +-- | A convenience alias for `Nothing` :: `Maybe` `Download`. +noDownload :: Maybe Download +noDownload = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDownloadMethod (t :: Symbol) (o :: *) :: * where + ResolveDownloadMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDownloadMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDownloadMethod "cancel" o = DownloadCancelMethodInfo + ResolveDownloadMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDownloadMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDownloadMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDownloadMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDownloadMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDownloadMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDownloadMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDownloadMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDownloadMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDownloadMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDownloadMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDownloadMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDownloadMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDownloadMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDownloadMethod "getAllowOverwrite" o = DownloadGetAllowOverwriteMethodInfo + ResolveDownloadMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDownloadMethod "getDestination" o = DownloadGetDestinationMethodInfo + ResolveDownloadMethod "getElapsedTime" o = DownloadGetElapsedTimeMethodInfo + ResolveDownloadMethod "getEstimatedProgress" o = DownloadGetEstimatedProgressMethodInfo + ResolveDownloadMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDownloadMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDownloadMethod "getReceivedDataLength" o = DownloadGetReceivedDataLengthMethodInfo + ResolveDownloadMethod "getRequest" o = DownloadGetRequestMethodInfo + ResolveDownloadMethod "getResponse" o = DownloadGetResponseMethodInfo + ResolveDownloadMethod "getWebView" o = DownloadGetWebViewMethodInfo + ResolveDownloadMethod "setAllowOverwrite" o = DownloadSetAllowOverwriteMethodInfo + ResolveDownloadMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDownloadMethod "setDestination" o = DownloadSetDestinationMethodInfo + ResolveDownloadMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDownloadMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDownloadMethod t Download, O.MethodInfo info Download p) => OL.IsLabel t (Download -> 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 Download::created-destination +{- | +This signal is emitted after 'GI.WebKit2.Objects.Download.Download'::@/decide-destination/@ and before +'GI.WebKit2.Objects.Download.Download'::@/received-data/@ to notify that destination file has been +created successfully at /@destination@/. +-} +type DownloadCreatedDestinationCallback = + T.Text + {- ^ /@destination@/: the destination URI -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DownloadCreatedDestinationCallback`@. +noDownloadCreatedDestinationCallback :: Maybe DownloadCreatedDestinationCallback +noDownloadCreatedDestinationCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_DownloadCreatedDestinationCallback = + Ptr () -> -- object + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_DownloadCreatedDestinationCallback`. +foreign import ccall "wrapper" + mk_DownloadCreatedDestinationCallback :: C_DownloadCreatedDestinationCallback -> IO (FunPtr C_DownloadCreatedDestinationCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_DownloadCreatedDestination :: MonadIO m => DownloadCreatedDestinationCallback -> m (GClosure C_DownloadCreatedDestinationCallback) +genClosure_DownloadCreatedDestination cb = liftIO $ do + let cb' = wrap_DownloadCreatedDestinationCallback cb + mk_DownloadCreatedDestinationCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `DownloadCreatedDestinationCallback` into a `C_DownloadCreatedDestinationCallback`. +wrap_DownloadCreatedDestinationCallback :: + DownloadCreatedDestinationCallback -> + C_DownloadCreatedDestinationCallback +wrap_DownloadCreatedDestinationCallback _cb _ destination _ = do + destination' <- cstringToText destination + _cb destination' + + +{- | +Connect a signal handler for the “@created-destination@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' download #createdDestination callback +@ +-} +onDownloadCreatedDestination :: (IsDownload a, MonadIO m) => a -> DownloadCreatedDestinationCallback -> m SignalHandlerId +onDownloadCreatedDestination obj cb = liftIO $ do + let cb' = wrap_DownloadCreatedDestinationCallback cb + cb'' <- mk_DownloadCreatedDestinationCallback cb' + connectSignalFunPtr obj "created-destination" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@created-destination@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' download #createdDestination callback +@ +-} +afterDownloadCreatedDestination :: (IsDownload a, MonadIO m) => a -> DownloadCreatedDestinationCallback -> m SignalHandlerId +afterDownloadCreatedDestination obj cb = liftIO $ do + let cb' = wrap_DownloadCreatedDestinationCallback cb + cb'' <- mk_DownloadCreatedDestinationCallback cb' + connectSignalFunPtr obj "created-destination" cb'' SignalConnectAfter + + +-- signal Download::decide-destination +{- | +This signal is emitted after response is received to +decide a destination URI for the download. If this signal is not +handled the file will be downloaded to 'GI.GLib.Enums.UserDirectoryDirectoryDownload' +directory using /@suggestedFilename@/. +-} +type DownloadDecideDestinationCallback = + T.Text + {- ^ /@suggestedFilename@/: the filename suggested for the download -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DownloadDecideDestinationCallback`@. +noDownloadDecideDestinationCallback :: Maybe DownloadDecideDestinationCallback +noDownloadDecideDestinationCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_DownloadDecideDestinationCallback = + Ptr () -> -- object + CString -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_DownloadDecideDestinationCallback`. +foreign import ccall "wrapper" + mk_DownloadDecideDestinationCallback :: C_DownloadDecideDestinationCallback -> IO (FunPtr C_DownloadDecideDestinationCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_DownloadDecideDestination :: MonadIO m => DownloadDecideDestinationCallback -> m (GClosure C_DownloadDecideDestinationCallback) +genClosure_DownloadDecideDestination cb = liftIO $ do + let cb' = wrap_DownloadDecideDestinationCallback cb + mk_DownloadDecideDestinationCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `DownloadDecideDestinationCallback` into a `C_DownloadDecideDestinationCallback`. +wrap_DownloadDecideDestinationCallback :: + DownloadDecideDestinationCallback -> + C_DownloadDecideDestinationCallback +wrap_DownloadDecideDestinationCallback _cb _ suggestedFilename _ = do + suggestedFilename' <- cstringToText suggestedFilename + result <- _cb suggestedFilename' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@decide-destination@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' download #decideDestination callback +@ +-} +onDownloadDecideDestination :: (IsDownload a, MonadIO m) => a -> DownloadDecideDestinationCallback -> m SignalHandlerId +onDownloadDecideDestination obj cb = liftIO $ do + let cb' = wrap_DownloadDecideDestinationCallback cb + cb'' <- mk_DownloadDecideDestinationCallback cb' + connectSignalFunPtr obj "decide-destination" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@decide-destination@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' download #decideDestination callback +@ +-} +afterDownloadDecideDestination :: (IsDownload a, MonadIO m) => a -> DownloadDecideDestinationCallback -> m SignalHandlerId +afterDownloadDecideDestination obj cb = liftIO $ do + let cb' = wrap_DownloadDecideDestinationCallback cb + cb'' <- mk_DownloadDecideDestinationCallback cb' + connectSignalFunPtr obj "decide-destination" cb'' SignalConnectAfter + + +-- signal Download::failed +{- | +This signal is emitted when an error occurs during the download +operation. The given /@error@/, of the domain @/WEBKIT_DOWNLOAD_ERROR/@, +contains further details of the failure. If the download is cancelled +with 'GI.WebKit2.Objects.Download.downloadCancel', this signal is emitted with error +'GI.WebKit2.Enums.DownloadErrorCancelledByUser'. The download operation finishes +after an error and 'GI.WebKit2.Objects.Download.Download'::@/finished/@ signal is emitted after this one. +-} +type DownloadFailedCallback = + GError + {- ^ /@error@/: the 'GError' that was triggered -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DownloadFailedCallback`@. +noDownloadFailedCallback :: Maybe DownloadFailedCallback +noDownloadFailedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_DownloadFailedCallback = + Ptr () -> -- object + Ptr GError -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_DownloadFailedCallback`. +foreign import ccall "wrapper" + mk_DownloadFailedCallback :: C_DownloadFailedCallback -> IO (FunPtr C_DownloadFailedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_DownloadFailed :: MonadIO m => DownloadFailedCallback -> m (GClosure C_DownloadFailedCallback) +genClosure_DownloadFailed cb = liftIO $ do + let cb' = wrap_DownloadFailedCallback cb + mk_DownloadFailedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `DownloadFailedCallback` into a `C_DownloadFailedCallback`. +wrap_DownloadFailedCallback :: + DownloadFailedCallback -> + C_DownloadFailedCallback +wrap_DownloadFailedCallback _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' download #failed callback +@ +-} +onDownloadFailed :: (IsDownload a, MonadIO m) => a -> DownloadFailedCallback -> m SignalHandlerId +onDownloadFailed obj cb = liftIO $ do + let cb' = wrap_DownloadFailedCallback cb + cb'' <- mk_DownloadFailedCallback 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' download #failed callback +@ +-} +afterDownloadFailed :: (IsDownload a, MonadIO m) => a -> DownloadFailedCallback -> m SignalHandlerId +afterDownloadFailed obj cb = liftIO $ do + let cb' = wrap_DownloadFailedCallback cb + cb'' <- mk_DownloadFailedCallback cb' + connectSignalFunPtr obj "failed" cb'' SignalConnectAfter + + +-- signal Download::finished +{- | +This signal is emitted when download finishes successfully or due to an error. +In case of errors 'GI.WebKit2.Objects.Download.Download'::@/failed/@ signal is emitted before this one. +-} +type DownloadFinishedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DownloadFinishedCallback`@. +noDownloadFinishedCallback :: Maybe DownloadFinishedCallback +noDownloadFinishedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_DownloadFinishedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_DownloadFinishedCallback`. +foreign import ccall "wrapper" + mk_DownloadFinishedCallback :: C_DownloadFinishedCallback -> IO (FunPtr C_DownloadFinishedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_DownloadFinished :: MonadIO m => DownloadFinishedCallback -> m (GClosure C_DownloadFinishedCallback) +genClosure_DownloadFinished cb = liftIO $ do + let cb' = wrap_DownloadFinishedCallback cb + mk_DownloadFinishedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `DownloadFinishedCallback` into a `C_DownloadFinishedCallback`. +wrap_DownloadFinishedCallback :: + DownloadFinishedCallback -> + C_DownloadFinishedCallback +wrap_DownloadFinishedCallback _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' download #finished callback +@ +-} +onDownloadFinished :: (IsDownload a, MonadIO m) => a -> DownloadFinishedCallback -> m SignalHandlerId +onDownloadFinished obj cb = liftIO $ do + let cb' = wrap_DownloadFinishedCallback cb + cb'' <- mk_DownloadFinishedCallback 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' download #finished callback +@ +-} +afterDownloadFinished :: (IsDownload a, MonadIO m) => a -> DownloadFinishedCallback -> m SignalHandlerId +afterDownloadFinished obj cb = liftIO $ do + let cb' = wrap_DownloadFinishedCallback cb + cb'' <- mk_DownloadFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' SignalConnectAfter + + +-- signal Download::received-data +{- | +This signal is emitted after response is received, +every time new data has been written to the destination. It\'s +useful to know the progress of the download operation. +-} +type DownloadReceivedDataCallback = + Word64 + {- ^ /@dataLength@/: the length of data received in bytes -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `DownloadReceivedDataCallback`@. +noDownloadReceivedDataCallback :: Maybe DownloadReceivedDataCallback +noDownloadReceivedDataCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_DownloadReceivedDataCallback = + Ptr () -> -- object + Word64 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_DownloadReceivedDataCallback`. +foreign import ccall "wrapper" + mk_DownloadReceivedDataCallback :: C_DownloadReceivedDataCallback -> IO (FunPtr C_DownloadReceivedDataCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_DownloadReceivedData :: MonadIO m => DownloadReceivedDataCallback -> m (GClosure C_DownloadReceivedDataCallback) +genClosure_DownloadReceivedData cb = liftIO $ do + let cb' = wrap_DownloadReceivedDataCallback cb + mk_DownloadReceivedDataCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `DownloadReceivedDataCallback` into a `C_DownloadReceivedDataCallback`. +wrap_DownloadReceivedDataCallback :: + DownloadReceivedDataCallback -> + C_DownloadReceivedDataCallback +wrap_DownloadReceivedDataCallback _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' download #receivedData callback +@ +-} +onDownloadReceivedData :: (IsDownload a, MonadIO m) => a -> DownloadReceivedDataCallback -> m SignalHandlerId +onDownloadReceivedData obj cb = liftIO $ do + let cb' = wrap_DownloadReceivedDataCallback cb + cb'' <- mk_DownloadReceivedDataCallback 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' download #receivedData callback +@ +-} +afterDownloadReceivedData :: (IsDownload a, MonadIO m) => a -> DownloadReceivedDataCallback -> m SignalHandlerId +afterDownloadReceivedData obj cb = liftIO $ do + let cb' = wrap_DownloadReceivedDataCallback cb + cb'' <- mk_DownloadReceivedDataCallback cb' + connectSignalFunPtr obj "received-data" cb'' SignalConnectAfter + + +-- VVV Prop "allow-overwrite" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@allow-overwrite@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' download #allowOverwrite +@ +-} +getDownloadAllowOverwrite :: (MonadIO m, IsDownload o) => o -> m Bool +getDownloadAllowOverwrite obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-overwrite" + +{- | +Set the value of the “@allow-overwrite@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' download [ #allowOverwrite 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDownloadAllowOverwrite :: (MonadIO m, IsDownload o) => o -> Bool -> m () +setDownloadAllowOverwrite obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-overwrite" val + +{- | +Construct a `GValueConstruct` with valid value for the “@allow-overwrite@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDownloadAllowOverwrite :: (IsDownload o) => Bool -> IO (GValueConstruct o) +constructDownloadAllowOverwrite val = B.Properties.constructObjectPropertyBool "allow-overwrite" val + +#if ENABLE_OVERLOADING +data DownloadAllowOverwritePropertyInfo +instance AttrInfo DownloadAllowOverwritePropertyInfo where + type AttrAllowedOps DownloadAllowOverwritePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DownloadAllowOverwritePropertyInfo = (~) Bool + type AttrBaseTypeConstraint DownloadAllowOverwritePropertyInfo = IsDownload + type AttrGetType DownloadAllowOverwritePropertyInfo = Bool + type AttrLabel DownloadAllowOverwritePropertyInfo = "allow-overwrite" + type AttrOrigin DownloadAllowOverwritePropertyInfo = Download + attrGet _ = getDownloadAllowOverwrite + attrSet _ = setDownloadAllowOverwrite + attrConstruct _ = constructDownloadAllowOverwrite + attrClear _ = undefined +#endif + +-- VVV Prop "destination" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@destination@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' download #destination +@ +-} +getDownloadDestination :: (MonadIO m, IsDownload o) => o -> m (Maybe T.Text) +getDownloadDestination obj = liftIO $ B.Properties.getObjectPropertyString obj "destination" + +#if ENABLE_OVERLOADING +data DownloadDestinationPropertyInfo +instance AttrInfo DownloadDestinationPropertyInfo where + type AttrAllowedOps DownloadDestinationPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DownloadDestinationPropertyInfo = (~) () + type AttrBaseTypeConstraint DownloadDestinationPropertyInfo = IsDownload + type AttrGetType DownloadDestinationPropertyInfo = (Maybe T.Text) + type AttrLabel DownloadDestinationPropertyInfo = "destination" + type AttrOrigin DownloadDestinationPropertyInfo = Download + attrGet _ = getDownloadDestination + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "estimated-progress" + -- Type: TBasicType TDouble + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@estimated-progress@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' download #estimatedProgress +@ +-} +getDownloadEstimatedProgress :: (MonadIO m, IsDownload o) => o -> m Double +getDownloadEstimatedProgress obj = liftIO $ B.Properties.getObjectPropertyDouble obj "estimated-progress" + +#if ENABLE_OVERLOADING +data DownloadEstimatedProgressPropertyInfo +instance AttrInfo DownloadEstimatedProgressPropertyInfo where + type AttrAllowedOps DownloadEstimatedProgressPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DownloadEstimatedProgressPropertyInfo = (~) () + type AttrBaseTypeConstraint DownloadEstimatedProgressPropertyInfo = IsDownload + type AttrGetType DownloadEstimatedProgressPropertyInfo = Double + type AttrLabel DownloadEstimatedProgressPropertyInfo = "estimated-progress" + type AttrOrigin DownloadEstimatedProgressPropertyInfo = Download + attrGet _ = getDownloadEstimatedProgress + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- 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' download #response +@ +-} +getDownloadResponse :: (MonadIO m, IsDownload o) => o -> m (Maybe WebKit2.URIResponse.URIResponse) +getDownloadResponse obj = liftIO $ B.Properties.getObjectPropertyObject obj "response" WebKit2.URIResponse.URIResponse + +#if ENABLE_OVERLOADING +data DownloadResponsePropertyInfo +instance AttrInfo DownloadResponsePropertyInfo where + type AttrAllowedOps DownloadResponsePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DownloadResponsePropertyInfo = (~) () + type AttrBaseTypeConstraint DownloadResponsePropertyInfo = IsDownload + type AttrGetType DownloadResponsePropertyInfo = (Maybe WebKit2.URIResponse.URIResponse) + type AttrLabel DownloadResponsePropertyInfo = "response" + type AttrOrigin DownloadResponsePropertyInfo = Download + attrGet _ = getDownloadResponse + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Download +type instance O.AttributeList Download = DownloadAttributeList +type DownloadAttributeList = ('[ '("allowOverwrite", DownloadAllowOverwritePropertyInfo), '("destination", DownloadDestinationPropertyInfo), '("estimatedProgress", DownloadEstimatedProgressPropertyInfo), '("response", DownloadResponsePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +downloadAllowOverwrite :: AttrLabelProxy "allowOverwrite" +downloadAllowOverwrite = AttrLabelProxy + +downloadDestination :: AttrLabelProxy "destination" +downloadDestination = AttrLabelProxy + +downloadEstimatedProgress :: AttrLabelProxy "estimatedProgress" +downloadEstimatedProgress = AttrLabelProxy + +downloadResponse :: AttrLabelProxy "response" +downloadResponse = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data DownloadCreatedDestinationSignalInfo +instance SignalInfo DownloadCreatedDestinationSignalInfo where + type HaskellCallbackType DownloadCreatedDestinationSignalInfo = DownloadCreatedDestinationCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_DownloadCreatedDestinationCallback cb + cb'' <- mk_DownloadCreatedDestinationCallback cb' + connectSignalFunPtr obj "created-destination" cb'' connectMode + +data DownloadDecideDestinationSignalInfo +instance SignalInfo DownloadDecideDestinationSignalInfo where + type HaskellCallbackType DownloadDecideDestinationSignalInfo = DownloadDecideDestinationCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_DownloadDecideDestinationCallback cb + cb'' <- mk_DownloadDecideDestinationCallback cb' + connectSignalFunPtr obj "decide-destination" cb'' connectMode + +data DownloadFailedSignalInfo +instance SignalInfo DownloadFailedSignalInfo where + type HaskellCallbackType DownloadFailedSignalInfo = DownloadFailedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_DownloadFailedCallback cb + cb'' <- mk_DownloadFailedCallback cb' + connectSignalFunPtr obj "failed" cb'' connectMode + +data DownloadFinishedSignalInfo +instance SignalInfo DownloadFinishedSignalInfo where + type HaskellCallbackType DownloadFinishedSignalInfo = DownloadFinishedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_DownloadFinishedCallback cb + cb'' <- mk_DownloadFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' connectMode + +data DownloadReceivedDataSignalInfo +instance SignalInfo DownloadReceivedDataSignalInfo where + type HaskellCallbackType DownloadReceivedDataSignalInfo = DownloadReceivedDataCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_DownloadReceivedDataCallback cb + cb'' <- mk_DownloadReceivedDataCallback cb' + connectSignalFunPtr obj "received-data" cb'' connectMode + +type instance O.SignalList Download = DownloadSignalList +type DownloadSignalList = ('[ '("createdDestination", DownloadCreatedDestinationSignalInfo), '("decideDestination", DownloadDecideDestinationSignalInfo), '("failed", DownloadFailedSignalInfo), '("finished", DownloadFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("receivedData", DownloadReceivedDataSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Download::cancel +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_cancel" webkit_download_cancel :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO () + +{- | +Cancels the download. When the ongoing download +operation is effectively cancelled the signal +'GI.WebKit2.Objects.Download.Download'::@/failed/@ is emitted with +'GI.WebKit2.Enums.DownloadErrorCancelledByUser' error. +-} +downloadCancel :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m () +downloadCancel download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + webkit_download_cancel download' + touchManagedPtr download + return () + +#if ENABLE_OVERLOADING +data DownloadCancelMethodInfo +instance (signature ~ (m ()), MonadIO m, IsDownload a) => O.MethodInfo DownloadCancelMethodInfo a signature where + overloadedMethod _ = downloadCancel + +#endif + +-- method Download::get_allow_overwrite +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_allow_overwrite" webkit_download_get_allow_overwrite :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO CInt + +{- | +Returns the current value of the 'GI.WebKit2.Objects.Download.Download':@/allow-overwrite/@ property, +which determines whether the download will overwrite an existing file on +disk, or if it will fail if the destination already exists. + +/Since: 2.6/ +-} +downloadGetAllowOverwrite :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m Bool + {- ^ __Returns:__ the current value of the 'GI.WebKit2.Objects.Download.Download':@/allow-overwrite/@ property -} +downloadGetAllowOverwrite download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_allow_overwrite download' + let result' = (/= 0) result + touchManagedPtr download + return result' + +#if ENABLE_OVERLOADING +data DownloadGetAllowOverwriteMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetAllowOverwriteMethodInfo a signature where + overloadedMethod _ = downloadGetAllowOverwrite + +#endif + +-- method Download::get_destination +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", 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_download_get_destination" webkit_download_get_destination :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO CString + +{- | +Obtains the URI to which the downloaded file will be written. You +can connect to 'GI.WebKit2.Objects.Download.Download'::@/created-destination/@ to make +sure this method returns a valid destination. +-} +downloadGetDestination :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the destination URI or 'Nothing' -} +downloadGetDestination download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_destination download' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr download + return maybeResult + +#if ENABLE_OVERLOADING +data DownloadGetDestinationMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetDestinationMethodInfo a signature where + overloadedMethod _ = downloadGetDestination + +#endif + +-- method Download::get_elapsed_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_elapsed_time" webkit_download_get_elapsed_time :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO CDouble + +{- | +Gets the elapsed time in seconds, including any fractional part. +If the download finished, had an error or was cancelled this is +the time between its start and the event. +-} +downloadGetElapsedTime :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m Double + {- ^ __Returns:__ seconds since the download was started -} +downloadGetElapsedTime download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_elapsed_time download' + let result' = realToFrac result + touchManagedPtr download + return result' + +#if ENABLE_OVERLOADING +data DownloadGetElapsedTimeMethodInfo +instance (signature ~ (m Double), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetElapsedTimeMethodInfo a signature where + overloadedMethod _ = downloadGetElapsedTime + +#endif + +-- method Download::get_estimated_progress +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_estimated_progress" webkit_download_get_estimated_progress :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO CDouble + +{- | +Gets the value of the 'GI.WebKit2.Objects.Download.Download':@/estimated-progress/@ property. +You can monitor the estimated progress of the download operation by +connecting to the notify::estimated-progress signal of /@download@/. +-} +downloadGetEstimatedProgress :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m Double + {- ^ __Returns:__ an estimate of the of the percent complete for a download + as a range from 0.0 to 1.0. -} +downloadGetEstimatedProgress download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_estimated_progress download' + let result' = realToFrac result + touchManagedPtr download + return result' + +#if ENABLE_OVERLOADING +data DownloadGetEstimatedProgressMethodInfo +instance (signature ~ (m Double), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetEstimatedProgressMethodInfo a signature where + overloadedMethod _ = downloadGetEstimatedProgress + +#endif + +-- method Download::get_received_data_length +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_received_data_length" webkit_download_get_received_data_length :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO Word64 + +{- | +Gets the length of the data already downloaded for /@download@/ +in bytes. +-} +downloadGetReceivedDataLength :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m Word64 + {- ^ __Returns:__ the amount of bytes already downloaded. -} +downloadGetReceivedDataLength download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_received_data_length download' + touchManagedPtr download + return result + +#if ENABLE_OVERLOADING +data DownloadGetReceivedDataLengthMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetReceivedDataLengthMethodInfo a signature where + overloadedMethod _ = downloadGetReceivedDataLength + +#endif + +-- method Download::get_request +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIRequest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_request" webkit_download_get_request :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO (Ptr WebKit2.URIRequest.URIRequest) + +{- | +Retrieves the 'GI.WebKit2.Objects.URIRequest.URIRequest' object that backs the download +process. +-} +downloadGetRequest :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m WebKit2.URIRequest.URIRequest + {- ^ __Returns:__ the 'GI.WebKit2.Objects.URIRequest.URIRequest' of /@download@/ -} +downloadGetRequest download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_request download' + checkUnexpectedReturnNULL "downloadGetRequest" result + result' <- (newObject WebKit2.URIRequest.URIRequest) result + touchManagedPtr download + return result' + +#if ENABLE_OVERLOADING +data DownloadGetRequestMethodInfo +instance (signature ~ (m WebKit2.URIRequest.URIRequest), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetRequestMethodInfo a signature where + overloadedMethod _ = downloadGetRequest + +#endif + +-- method Download::get_response +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", 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_download_get_response" webkit_download_get_response :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO (Ptr WebKit2.URIResponse.URIResponse) + +{- | +Retrieves the 'GI.WebKit2.Objects.URIResponse.URIResponse' object that backs the download +process. 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. +-} +downloadGetResponse :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m (Maybe WebKit2.URIResponse.URIResponse) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.URIResponse.URIResponse', or 'Nothing' if + the response hasn\'t been received yet. -} +downloadGetResponse download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_response download' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.URIResponse.URIResponse) result' + return result'' + touchManagedPtr download + return maybeResult + +#if ENABLE_OVERLOADING +data DownloadGetResponseMethodInfo +instance (signature ~ (m (Maybe WebKit2.URIResponse.URIResponse)), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetResponseMethodInfo a signature where + overloadedMethod _ = downloadGetResponse + +#endif + +-- method Download::get_web_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_get_web_view" webkit_download_get_web_view :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + IO (Ptr WebKit2.WebView.WebView) + +{- | +Get the 'GI.WebKit2.Objects.WebView.WebView' that initiated the download. +-} +downloadGetWebView :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> m (Maybe WebKit2.WebView.WebView) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebView.WebView' that initiated /@download@/, + or 'Nothing' if /@download@/ was not initiated by a 'GI.WebKit2.Objects.WebView.WebView'. -} +downloadGetWebView download = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + result <- webkit_download_get_web_view download' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.WebView.WebView) result' + return result'' + touchManagedPtr download + return maybeResult + +#if ENABLE_OVERLOADING +data DownloadGetWebViewMethodInfo +instance (signature ~ (m (Maybe WebKit2.WebView.WebView)), MonadIO m, IsDownload a) => O.MethodInfo DownloadGetWebViewMethodInfo a signature where + overloadedMethod _ = downloadGetWebView + +#endif + +-- method Download::set_allow_overwrite +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the #WebKitDownload:allow-overwrite property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_set_allow_overwrite" webkit_download_set_allow_overwrite :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + CInt -> -- allowed : TBasicType TBoolean + IO () + +{- | +Sets the 'GI.WebKit2.Objects.Download.Download':@/allow-overwrite/@ property, which determines whether +the download may overwrite an existing file on disk, or if it will fail if +the destination already exists. + +/Since: 2.6/ +-} +downloadSetAllowOverwrite :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> Bool + {- ^ /@allowed@/: the new value for the 'GI.WebKit2.Objects.Download.Download':@/allow-overwrite/@ property -} + -> m () +downloadSetAllowOverwrite download allowed = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + let allowed' = (fromIntegral . fromEnum) allowed + webkit_download_set_allow_overwrite download' allowed' + touchManagedPtr download + return () + +#if ENABLE_OVERLOADING +data DownloadSetAllowOverwriteMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsDownload a) => O.MethodInfo DownloadSetAllowOverwriteMethodInfo a signature where + overloadedMethod _ = downloadSetAllowOverwrite + +#endif + +-- method Download::set_destination +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "download", argType = TInterface (Name {namespace = "WebKit2", name = "Download"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitDownload", 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 destination URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_download_set_destination" webkit_download_set_destination :: + Ptr Download -> -- download : TInterface (Name {namespace = "WebKit2", name = "Download"}) + CString -> -- uri : TBasicType TUTF8 + IO () + +{- | +Sets the URI to which the downloaded file will be written. +This method should be called before the download transfer +starts or it will not have any effect on the ongoing download +operation. To set the destination using the filename suggested +by the server connect to 'GI.WebKit2.Objects.Download.Download'::@/decide-destination/@ +signal and call 'GI.WebKit2.Objects.Download.downloadSetDestination'. If you want to +set a fixed destination URI that doesn\'t depend on the suggested +filename you can connect to notify::response signal and call +'GI.WebKit2.Objects.Download.downloadSetDestination'. +If 'GI.WebKit2.Objects.Download.Download'::@/decide-destination/@ signal is not handled +and destination URI is not set when the download transfer starts, +the file will be saved with the filename suggested by the server in +'GI.GLib.Enums.UserDirectoryDirectoryDownload' directory. +-} +downloadSetDestination :: + (B.CallStack.HasCallStack, MonadIO m, IsDownload a) => + a + {- ^ /@download@/: a 'GI.WebKit2.Objects.Download.Download' -} + -> T.Text + {- ^ /@uri@/: the destination URI -} + -> m () +downloadSetDestination download uri = liftIO $ do + download' <- unsafeManagedPtrCastPtr download + uri' <- textToCString uri + webkit_download_set_destination download' uri' + touchManagedPtr download + freeMem uri' + return () + +#if ENABLE_OVERLOADING +data DownloadSetDestinationMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDownload a) => O.MethodInfo DownloadSetDestinationMethodInfo a signature where + overloadedMethod _ = downloadSetDestination + +#endif + + diff --git a/GI/WebKit2/Objects/Download.hs-boot b/GI/WebKit2/Objects/Download.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Download.hs-boot @@ -0,0 +1,89 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.Download 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 + +newtype Download = Download (ManagedPtr Download) +instance GObject Download where +class (GObject o, O.IsDescendantOf Download o) => IsDownload o +instance (GObject o, O.IsDescendantOf Download o) => IsDownload o +instance O.HasParentTypes Download +#if ENABLE_OVERLOADING +data DownloadAllowOverwritePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DownloadDestinationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DownloadEstimatedProgressPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DownloadResponsePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DownloadCreatedDestinationSignalInfo +#endif +#if ENABLE_OVERLOADING +data DownloadDecideDestinationSignalInfo +#endif +#if ENABLE_OVERLOADING +data DownloadFailedSignalInfo +#endif +#if ENABLE_OVERLOADING +data DownloadFinishedSignalInfo +#endif +#if ENABLE_OVERLOADING +data DownloadReceivedDataSignalInfo +#endif +#if ENABLE_OVERLOADING +data DownloadCancelMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetAllowOverwriteMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetDestinationMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetElapsedTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetEstimatedProgressMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetReceivedDataLengthMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetRequestMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetResponseMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadGetWebViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadSetAllowOverwriteMethodInfo +#endif +#if ENABLE_OVERLOADING +data DownloadSetDestinationMethodInfo +#endif diff --git a/GI/WebKit2/Objects/EditorState.hs b/GI/WebKit2/Objects/EditorState.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/EditorState.hs @@ -0,0 +1,455 @@ + + +{- | +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.EditorState + ( + +-- * Exported types + EditorState(..) , + IsEditorState , + toEditorState , + noEditorState , + + + -- * Methods +-- ** getTypingAttributes #method:getTypingAttributes# + +#if ENABLE_OVERLOADING + EditorStateGetTypingAttributesMethodInfo, +#endif + editorStateGetTypingAttributes , + + +-- ** isCopyAvailable #method:isCopyAvailable# + +#if ENABLE_OVERLOADING + EditorStateIsCopyAvailableMethodInfo , +#endif + editorStateIsCopyAvailable , + + +-- ** isCutAvailable #method:isCutAvailable# + +#if ENABLE_OVERLOADING + EditorStateIsCutAvailableMethodInfo , +#endif + editorStateIsCutAvailable , + + +-- ** isPasteAvailable #method:isPasteAvailable# + +#if ENABLE_OVERLOADING + EditorStateIsPasteAvailableMethodInfo , +#endif + editorStateIsPasteAvailable , + + +-- ** isRedoAvailable #method:isRedoAvailable# + +#if ENABLE_OVERLOADING + EditorStateIsRedoAvailableMethodInfo , +#endif + editorStateIsRedoAvailable , + + +-- ** isUndoAvailable #method:isUndoAvailable# + +#if ENABLE_OVERLOADING + EditorStateIsUndoAvailableMethodInfo , +#endif + editorStateIsUndoAvailable , + + + + + -- * Properties +-- ** typingAttributes #attr:typingAttributes# +{- | Bitmask of 'GI.WebKit2.Flags.EditorTypingAttributes' flags. +See 'GI.WebKit2.Objects.EditorState.editorStateGetTypingAttributes' for more information. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + EditorStateTypingAttributesPropertyInfo , +#endif +#if ENABLE_OVERLOADING + editorStateTypingAttributes , +#endif + getEditorStateTypingAttributes , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype EditorState = EditorState (ManagedPtr EditorState) +foreign import ccall "webkit_editor_state_get_type" + c_webkit_editor_state_get_type :: IO GType + +instance GObject EditorState where + gobjectType = c_webkit_editor_state_get_type + + +-- | Type class for types which can be safely cast to `EditorState`, for instance with `toEditorState`. +class (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o +instance (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o + +instance O.HasParentTypes EditorState +type instance O.ParentTypes EditorState = '[GObject.Object.Object] + +-- | Cast to `EditorState`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toEditorState :: (MonadIO m, IsEditorState o) => o -> m EditorState +toEditorState = liftIO . unsafeCastTo EditorState + +-- | A convenience alias for `Nothing` :: `Maybe` `EditorState`. +noEditorState :: Maybe EditorState +noEditorState = Nothing + +#if ENABLE_OVERLOADING +type family ResolveEditorStateMethod (t :: Symbol) (o :: *) :: * where + ResolveEditorStateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveEditorStateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveEditorStateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveEditorStateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveEditorStateMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveEditorStateMethod "isCopyAvailable" o = EditorStateIsCopyAvailableMethodInfo + ResolveEditorStateMethod "isCutAvailable" o = EditorStateIsCutAvailableMethodInfo + ResolveEditorStateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveEditorStateMethod "isPasteAvailable" o = EditorStateIsPasteAvailableMethodInfo + ResolveEditorStateMethod "isRedoAvailable" o = EditorStateIsRedoAvailableMethodInfo + ResolveEditorStateMethod "isUndoAvailable" o = EditorStateIsUndoAvailableMethodInfo + ResolveEditorStateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveEditorStateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveEditorStateMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveEditorStateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveEditorStateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveEditorStateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveEditorStateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveEditorStateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveEditorStateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveEditorStateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveEditorStateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveEditorStateMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveEditorStateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveEditorStateMethod "getTypingAttributes" o = EditorStateGetTypingAttributesMethodInfo + ResolveEditorStateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveEditorStateMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveEditorStateMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveEditorStateMethod t EditorState, O.MethodInfo info EditorState p) => OL.IsLabel t (EditorState -> 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 + +-- VVV Prop "typing-attributes" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@typing-attributes@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' editorState #typingAttributes +@ +-} +getEditorStateTypingAttributes :: (MonadIO m, IsEditorState o) => o -> m Word32 +getEditorStateTypingAttributes obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "typing-attributes" + +#if ENABLE_OVERLOADING +data EditorStateTypingAttributesPropertyInfo +instance AttrInfo EditorStateTypingAttributesPropertyInfo where + type AttrAllowedOps EditorStateTypingAttributesPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint EditorStateTypingAttributesPropertyInfo = (~) () + type AttrBaseTypeConstraint EditorStateTypingAttributesPropertyInfo = IsEditorState + type AttrGetType EditorStateTypingAttributesPropertyInfo = Word32 + type AttrLabel EditorStateTypingAttributesPropertyInfo = "typing-attributes" + type AttrOrigin EditorStateTypingAttributesPropertyInfo = EditorState + attrGet _ = getEditorStateTypingAttributes + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList EditorState +type instance O.AttributeList EditorState = EditorStateAttributeList +type EditorStateAttributeList = ('[ '("typingAttributes", EditorStateTypingAttributesPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +editorStateTypingAttributes :: AttrLabelProxy "typingAttributes" +editorStateTypingAttributes = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList EditorState = EditorStateSignalList +type EditorStateSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method EditorState::get_typing_attributes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_get_typing_attributes" webkit_editor_state_get_typing_attributes :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO Word32 + +{- | +Gets the typing attributes at the current cursor position. +If there is a selection, this returns the typing attributes +of the selected text. Note that in case of a selection, +typing attributes are considered active only when they are +present throughout the selection. + +/Since: 2.10/ +-} +editorStateGetTypingAttributes :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Word32 + {- ^ __Returns:__ a bitmask of 'GI.WebKit2.Flags.EditorTypingAttributes' flags -} +editorStateGetTypingAttributes editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_get_typing_attributes editorState' + touchManagedPtr editorState + return result + +#if ENABLE_OVERLOADING +data EditorStateGetTypingAttributesMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateGetTypingAttributesMethodInfo a signature where + overloadedMethod _ = editorStateGetTypingAttributes + +#endif + +-- method EditorState::is_copy_available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_is_copy_available" webkit_editor_state_is_copy_available :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO CInt + +{- | +Gets whether a copy command can be issued. + +/Since: 2.20/ +-} +editorStateIsCopyAvailable :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Bool + {- ^ __Returns:__ 'True' if copy is currently available -} +editorStateIsCopyAvailable editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_is_copy_available editorState' + let result' = (/= 0) result + touchManagedPtr editorState + return result' + +#if ENABLE_OVERLOADING +data EditorStateIsCopyAvailableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsCopyAvailableMethodInfo a signature where + overloadedMethod _ = editorStateIsCopyAvailable + +#endif + +-- method EditorState::is_cut_available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_is_cut_available" webkit_editor_state_is_cut_available :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO CInt + +{- | +Gets whether a cut command can be issued. + +/Since: 2.20/ +-} +editorStateIsCutAvailable :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Bool + {- ^ __Returns:__ 'True' if cut is currently available -} +editorStateIsCutAvailable editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_is_cut_available editorState' + let result' = (/= 0) result + touchManagedPtr editorState + return result' + +#if ENABLE_OVERLOADING +data EditorStateIsCutAvailableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsCutAvailableMethodInfo a signature where + overloadedMethod _ = editorStateIsCutAvailable + +#endif + +-- method EditorState::is_paste_available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_is_paste_available" webkit_editor_state_is_paste_available :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO CInt + +{- | +Gets whether a paste command can be issued. + +/Since: 2.20/ +-} +editorStateIsPasteAvailable :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Bool + {- ^ __Returns:__ 'True' if paste is currently available -} +editorStateIsPasteAvailable editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_is_paste_available editorState' + let result' = (/= 0) result + touchManagedPtr editorState + return result' + +#if ENABLE_OVERLOADING +data EditorStateIsPasteAvailableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsPasteAvailableMethodInfo a signature where + overloadedMethod _ = editorStateIsPasteAvailable + +#endif + +-- method EditorState::is_redo_available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_is_redo_available" webkit_editor_state_is_redo_available :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO CInt + +{- | +Gets whether a redo command can be issued. + +/Since: 2.20/ +-} +editorStateIsRedoAvailable :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Bool + {- ^ __Returns:__ 'True' if redo is currently available -} +editorStateIsRedoAvailable editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_is_redo_available editorState' + let result' = (/= 0) result + touchManagedPtr editorState + return result' + +#if ENABLE_OVERLOADING +data EditorStateIsRedoAvailableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsRedoAvailableMethodInfo a signature where + overloadedMethod _ = editorStateIsRedoAvailable + +#endif + +-- method EditorState::is_undo_available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_editor_state_is_undo_available" webkit_editor_state_is_undo_available :: + Ptr EditorState -> -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"}) + IO CInt + +{- | +Gets whether an undo command can be issued. + +/Since: 2.20/ +-} +editorStateIsUndoAvailable :: + (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) => + a + {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -} + -> m Bool + {- ^ __Returns:__ 'True' if undo is currently available -} +editorStateIsUndoAvailable editorState = liftIO $ do + editorState' <- unsafeManagedPtrCastPtr editorState + result <- webkit_editor_state_is_undo_available editorState' + let result' = (/= 0) result + touchManagedPtr editorState + return result' + +#if ENABLE_OVERLOADING +data EditorStateIsUndoAvailableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsUndoAvailableMethodInfo a signature where + overloadedMethod _ = editorStateIsUndoAvailable + +#endif + + diff --git a/GI/WebKit2/Objects/EditorState.hs-boot b/GI/WebKit2/Objects/EditorState.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/EditorState.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.EditorState 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 + +newtype EditorState = EditorState (ManagedPtr EditorState) +instance GObject EditorState where +class (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o +instance (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o +instance O.HasParentTypes EditorState +#if ENABLE_OVERLOADING +data EditorStateTypingAttributesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateGetTypingAttributesMethodInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateIsCopyAvailableMethodInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateIsCutAvailableMethodInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateIsPasteAvailableMethodInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateIsRedoAvailableMethodInfo +#endif +#if ENABLE_OVERLOADING +data EditorStateIsUndoAvailableMethodInfo +#endif diff --git a/GI/WebKit2/Objects/FaviconDatabase.hs b/GI/WebKit2/Objects/FaviconDatabase.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FaviconDatabase.hs @@ -0,0 +1,464 @@ + + +{- | +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.FaviconDatabase + ( + +-- * Exported types + FaviconDatabase(..) , + IsFaviconDatabase , + toFaviconDatabase , + noFaviconDatabase , + + + -- * Methods +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + FaviconDatabaseClearMethodInfo , +#endif + faviconDatabaseClear , + + +-- ** getFavicon #method:getFavicon# + +#if ENABLE_OVERLOADING + FaviconDatabaseGetFaviconMethodInfo , +#endif + faviconDatabaseGetFavicon , + + +-- ** getFaviconFinish #method:getFaviconFinish# + +#if ENABLE_OVERLOADING + FaviconDatabaseGetFaviconFinishMethodInfo, +#endif + faviconDatabaseGetFaviconFinish , + + +-- ** getFaviconUri #method:getFaviconUri# + +#if ENABLE_OVERLOADING + FaviconDatabaseGetFaviconUriMethodInfo , +#endif + faviconDatabaseGetFaviconUri , + + + + + -- * Signals +-- ** faviconChanged #signal:faviconChanged# + + C_FaviconDatabaseFaviconChangedCallback , + FaviconDatabaseFaviconChangedCallback , +#if ENABLE_OVERLOADING + FaviconDatabaseFaviconChangedSignalInfo , +#endif + afterFaviconDatabaseFaviconChanged , + genClosure_FaviconDatabaseFaviconChanged, + mk_FaviconDatabaseFaviconChangedCallback, + noFaviconDatabaseFaviconChangedCallback , + onFaviconDatabaseFaviconChanged , + wrap_FaviconDatabaseFaviconChangedCallback, + + + + + ) 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.Cairo.Structs.Surface as Cairo.Surface +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.Objects.Cancellable as Gio.Cancellable + +-- | Memory-managed wrapper type. +newtype FaviconDatabase = FaviconDatabase (ManagedPtr FaviconDatabase) +foreign import ccall "webkit_favicon_database_get_type" + c_webkit_favicon_database_get_type :: IO GType + +instance GObject FaviconDatabase where + gobjectType = c_webkit_favicon_database_get_type + + +-- | Type class for types which can be safely cast to `FaviconDatabase`, for instance with `toFaviconDatabase`. +class (GObject o, O.IsDescendantOf FaviconDatabase o) => IsFaviconDatabase o +instance (GObject o, O.IsDescendantOf FaviconDatabase o) => IsFaviconDatabase o + +instance O.HasParentTypes FaviconDatabase +type instance O.ParentTypes FaviconDatabase = '[GObject.Object.Object] + +-- | Cast to `FaviconDatabase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFaviconDatabase :: (MonadIO m, IsFaviconDatabase o) => o -> m FaviconDatabase +toFaviconDatabase = liftIO . unsafeCastTo FaviconDatabase + +-- | A convenience alias for `Nothing` :: `Maybe` `FaviconDatabase`. +noFaviconDatabase :: Maybe FaviconDatabase +noFaviconDatabase = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFaviconDatabaseMethod (t :: Symbol) (o :: *) :: * where + ResolveFaviconDatabaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFaviconDatabaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFaviconDatabaseMethod "clear" o = FaviconDatabaseClearMethodInfo + ResolveFaviconDatabaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFaviconDatabaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFaviconDatabaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFaviconDatabaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFaviconDatabaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFaviconDatabaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFaviconDatabaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFaviconDatabaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFaviconDatabaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFaviconDatabaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFaviconDatabaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFaviconDatabaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFaviconDatabaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFaviconDatabaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFaviconDatabaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFaviconDatabaseMethod "getFavicon" o = FaviconDatabaseGetFaviconMethodInfo + ResolveFaviconDatabaseMethod "getFaviconFinish" o = FaviconDatabaseGetFaviconFinishMethodInfo + ResolveFaviconDatabaseMethod "getFaviconUri" o = FaviconDatabaseGetFaviconUriMethodInfo + ResolveFaviconDatabaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFaviconDatabaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFaviconDatabaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFaviconDatabaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFaviconDatabaseMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFaviconDatabaseMethod t FaviconDatabase, O.MethodInfo info FaviconDatabase p) => OL.IsLabel t (FaviconDatabase -> 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 FaviconDatabase::favicon-changed +{- | +This signal is emitted when the favicon URI of /@pageUri@/ has +been changed to /@faviconUri@/ in the database. You can connect +to this signal and call 'GI.WebKit2.Objects.FaviconDatabase.faviconDatabaseGetFavicon' +to get the favicon. If you are interested in the favicon of a +'GI.WebKit2.Objects.WebView.WebView' it\'s easier to use the 'GI.WebKit2.Objects.WebView.WebView':@/favicon/@ +property. See 'GI.WebKit2.Objects.WebView.webViewGetFavicon' for more details. +-} +type FaviconDatabaseFaviconChangedCallback = + T.Text + {- ^ /@pageUri@/: the URI of the Web page containing the icon -} + -> T.Text + {- ^ /@faviconUri@/: the URI of the favicon -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `FaviconDatabaseFaviconChangedCallback`@. +noFaviconDatabaseFaviconChangedCallback :: Maybe FaviconDatabaseFaviconChangedCallback +noFaviconDatabaseFaviconChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_FaviconDatabaseFaviconChangedCallback = + Ptr () -> -- object + CString -> + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_FaviconDatabaseFaviconChangedCallback`. +foreign import ccall "wrapper" + mk_FaviconDatabaseFaviconChangedCallback :: C_FaviconDatabaseFaviconChangedCallback -> IO (FunPtr C_FaviconDatabaseFaviconChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_FaviconDatabaseFaviconChanged :: MonadIO m => FaviconDatabaseFaviconChangedCallback -> m (GClosure C_FaviconDatabaseFaviconChangedCallback) +genClosure_FaviconDatabaseFaviconChanged cb = liftIO $ do + let cb' = wrap_FaviconDatabaseFaviconChangedCallback cb + mk_FaviconDatabaseFaviconChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `FaviconDatabaseFaviconChangedCallback` into a `C_FaviconDatabaseFaviconChangedCallback`. +wrap_FaviconDatabaseFaviconChangedCallback :: + FaviconDatabaseFaviconChangedCallback -> + C_FaviconDatabaseFaviconChangedCallback +wrap_FaviconDatabaseFaviconChangedCallback _cb _ pageUri faviconUri _ = do + pageUri' <- cstringToText pageUri + faviconUri' <- cstringToText faviconUri + _cb pageUri' faviconUri' + + +{- | +Connect a signal handler for the “@favicon-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' faviconDatabase #faviconChanged callback +@ +-} +onFaviconDatabaseFaviconChanged :: (IsFaviconDatabase a, MonadIO m) => a -> FaviconDatabaseFaviconChangedCallback -> m SignalHandlerId +onFaviconDatabaseFaviconChanged obj cb = liftIO $ do + let cb' = wrap_FaviconDatabaseFaviconChangedCallback cb + cb'' <- mk_FaviconDatabaseFaviconChangedCallback cb' + connectSignalFunPtr obj "favicon-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@favicon-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' faviconDatabase #faviconChanged callback +@ +-} +afterFaviconDatabaseFaviconChanged :: (IsFaviconDatabase a, MonadIO m) => a -> FaviconDatabaseFaviconChangedCallback -> m SignalHandlerId +afterFaviconDatabaseFaviconChanged obj cb = liftIO $ do + let cb' = wrap_FaviconDatabaseFaviconChangedCallback cb + cb'' <- mk_FaviconDatabaseFaviconChangedCallback cb' + connectSignalFunPtr obj "favicon-changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FaviconDatabase +type instance O.AttributeList FaviconDatabase = FaviconDatabaseAttributeList +type FaviconDatabaseAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data FaviconDatabaseFaviconChangedSignalInfo +instance SignalInfo FaviconDatabaseFaviconChangedSignalInfo where + type HaskellCallbackType FaviconDatabaseFaviconChangedSignalInfo = FaviconDatabaseFaviconChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_FaviconDatabaseFaviconChangedCallback cb + cb'' <- mk_FaviconDatabaseFaviconChangedCallback cb' + connectSignalFunPtr obj "favicon-changed" cb'' connectMode + +type instance O.SignalList FaviconDatabase = FaviconDatabaseSignalList +type FaviconDatabaseSignalList = ('[ '("faviconChanged", FaviconDatabaseFaviconChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FaviconDatabase::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "database", argType = TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFaviconDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_favicon_database_clear" webkit_favicon_database_clear :: + Ptr FaviconDatabase -> -- database : TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}) + IO () + +{- | +Clears all icons from the database. +-} +faviconDatabaseClear :: + (B.CallStack.HasCallStack, MonadIO m, IsFaviconDatabase a) => + a + {- ^ /@database@/: a 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' -} + -> m () +faviconDatabaseClear database = liftIO $ do + database' <- unsafeManagedPtrCastPtr database + webkit_favicon_database_clear database' + touchManagedPtr database + return () + +#if ENABLE_OVERLOADING +data FaviconDatabaseClearMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFaviconDatabase a) => O.MethodInfo FaviconDatabaseClearMethodInfo a signature where + overloadedMethod _ = faviconDatabaseClear + +#endif + +-- method FaviconDatabase::get_favicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "database", argType = TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFaviconDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "page_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URI of the page for which we want to retrieve the favicon", 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.", 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\n satisfied or %NULL if you don't care about the result.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_favicon_database_get_favicon" webkit_favicon_database_get_favicon :: + Ptr FaviconDatabase -> -- database : TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}) + CString -> -- page_uri : TBasicType TUTF8 + 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 obtains a 'GI.Cairo.Structs.Surface.Surface' of the favicon for the +given page URI. It returns the cached icon if it\'s in the database +asynchronously waiting for the icon to be read from the database. + +This is an asynchronous method. When the operation is finished, callback will +be invoked. You can then call 'GI.WebKit2.Objects.FaviconDatabase.faviconDatabaseGetFaviconFinish' +to get the result of the operation. + +You must call 'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory' for +the 'GI.WebKit2.Objects.WebContext.WebContext' associated with this 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' +before attempting to use this function; otherwise, +'GI.WebKit2.Objects.FaviconDatabase.faviconDatabaseGetFaviconFinish' will return +'GI.WebKit2.Enums.FaviconDatabaseErrorNotInitialized'. +-} +faviconDatabaseGetFavicon :: + (B.CallStack.HasCallStack, MonadIO m, IsFaviconDatabase a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@database@/: a 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' -} + -> T.Text + {- ^ /@pageUri@/: URI of the page for which we want to retrieve the favicon -} + -> Maybe (b) + {- ^ /@cancellable@/: A 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing'. -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: A 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is + satisfied or 'Nothing' if you don\'t care about the result. -} + -> m () +faviconDatabaseGetFavicon database pageUri cancellable callback = liftIO $ do + database' <- unsafeManagedPtrCastPtr database + pageUri' <- textToCString pageUri + 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_favicon_database_get_favicon database' pageUri' maybeCancellable maybeCallback userData + touchManagedPtr database + whenJust cancellable touchManagedPtr + freeMem pageUri' + return () + +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFaviconDatabase a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FaviconDatabaseGetFaviconMethodInfo a signature where + overloadedMethod _ = faviconDatabaseGetFavicon + +#endif + +-- method FaviconDatabase::get_favicon_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "database", argType = TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFaviconDatabase", 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 obtained from the #GAsyncReadyCallback passed to webkit_favicon_database_get_favicon()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_favicon_database_get_favicon_finish" webkit_favicon_database_get_favicon_finish :: + Ptr FaviconDatabase -> -- database : TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Cairo.Surface.Surface) + +{- | +Finishes an operation started with 'GI.WebKit2.Objects.FaviconDatabase.faviconDatabaseGetFavicon'. +-} +faviconDatabaseGetFaviconFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsFaviconDatabase a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@database@/: a 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' -} + -> b + {- ^ /@result@/: A 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed to 'GI.WebKit2.Objects.FaviconDatabase.faviconDatabaseGetFavicon' -} + -> m Cairo.Surface.Surface + {- ^ __Returns:__ a new reference to a 'GI.Cairo.Structs.Surface.Surface', or +'Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +faviconDatabaseGetFaviconFinish database result_ = liftIO $ do + database' <- unsafeManagedPtrCastPtr database + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_favicon_database_get_favicon_finish database' result_' + checkUnexpectedReturnNULL "faviconDatabaseGetFaviconFinish" result + result' <- (wrapBoxed Cairo.Surface.Surface) result + touchManagedPtr database + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconFinishMethodInfo +instance (signature ~ (b -> m Cairo.Surface.Surface), MonadIO m, IsFaviconDatabase a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FaviconDatabaseGetFaviconFinishMethodInfo a signature where + overloadedMethod _ = faviconDatabaseGetFaviconFinish + +#endif + +-- method FaviconDatabase::get_favicon_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "database", argType = TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFaviconDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "page_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "URI of the page containing the icon", 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_favicon_database_get_favicon_uri" webkit_favicon_database_get_favicon_uri :: + Ptr FaviconDatabase -> -- database : TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"}) + CString -> -- page_uri : TBasicType TUTF8 + IO CString + +{- | +Obtains the URI of the favicon for the given /@pageUri@/. +-} +faviconDatabaseGetFaviconUri :: + (B.CallStack.HasCallStack, MonadIO m, IsFaviconDatabase a) => + a + {- ^ /@database@/: a 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' -} + -> T.Text + {- ^ /@pageUri@/: URI of the page containing the icon -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a newly allocated URI for the favicon, or 'Nothing' if the +database doesn\'t have a favicon for /@pageUri@/. -} +faviconDatabaseGetFaviconUri database pageUri = liftIO $ do + database' <- unsafeManagedPtrCastPtr database + pageUri' <- textToCString pageUri + result <- webkit_favicon_database_get_favicon_uri database' pageUri' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr database + freeMem pageUri' + return maybeResult + +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconUriMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsFaviconDatabase a) => O.MethodInfo FaviconDatabaseGetFaviconUriMethodInfo a signature where + overloadedMethod _ = faviconDatabaseGetFaviconUri + +#endif + + diff --git a/GI/WebKit2/Objects/FaviconDatabase.hs-boot b/GI/WebKit2/Objects/FaviconDatabase.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FaviconDatabase.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.FaviconDatabase 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 + +newtype FaviconDatabase = FaviconDatabase (ManagedPtr FaviconDatabase) +instance GObject FaviconDatabase where +class (GObject o, O.IsDescendantOf FaviconDatabase o) => IsFaviconDatabase o +instance (GObject o, O.IsDescendantOf FaviconDatabase o) => IsFaviconDatabase o +instance O.HasParentTypes FaviconDatabase +#if ENABLE_OVERLOADING +data FaviconDatabaseFaviconChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data FaviconDatabaseClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconMethodInfo +#endif +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data FaviconDatabaseGetFaviconUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/FileChooserRequest.hs b/GI/WebKit2/Objects/FileChooserRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FileChooserRequest.hs @@ -0,0 +1,630 @@ + + +{- | +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.FileChooserRequest + ( + +-- * Exported types + FileChooserRequest(..) , + IsFileChooserRequest , + toFileChooserRequest , + noFileChooserRequest , + + + -- * Methods +-- ** cancel #method:cancel# + +#if ENABLE_OVERLOADING + FileChooserRequestCancelMethodInfo , +#endif + fileChooserRequestCancel , + + +-- ** getMimeTypes #method:getMimeTypes# + +#if ENABLE_OVERLOADING + FileChooserRequestGetMimeTypesMethodInfo, +#endif + fileChooserRequestGetMimeTypes , + + +-- ** getMimeTypesFilter #method:getMimeTypesFilter# + +#if ENABLE_OVERLOADING + FileChooserRequestGetMimeTypesFilterMethodInfo, +#endif + fileChooserRequestGetMimeTypesFilter , + + +-- ** getSelectMultiple #method:getSelectMultiple# + +#if ENABLE_OVERLOADING + FileChooserRequestGetSelectMultipleMethodInfo, +#endif + fileChooserRequestGetSelectMultiple , + + +-- ** getSelectedFiles #method:getSelectedFiles# + +#if ENABLE_OVERLOADING + FileChooserRequestGetSelectedFilesMethodInfo, +#endif + fileChooserRequestGetSelectedFiles , + + +-- ** selectFiles #method:selectFiles# + +#if ENABLE_OVERLOADING + FileChooserRequestSelectFilesMethodInfo , +#endif + fileChooserRequestSelectFiles , + + + + + -- * Properties +-- ** filter #attr:filter# +{- | The filter currently associated with the request. See +'GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetMimeTypesFilter' for more +details. +-} +#if ENABLE_OVERLOADING + FileChooserRequestFilterPropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileChooserRequestFilter , +#endif + getFileChooserRequestFilter , + + +-- ** mimeTypes #attr:mimeTypes# +{- | A 'Nothing'-terminated array of strings containing the list of MIME +types the file chooser dialog should handle. See +'GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetMimeTypes' for more details. +-} +#if ENABLE_OVERLOADING + FileChooserRequestMimeTypesPropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileChooserRequestMimeTypes , +#endif + getFileChooserRequestMimeTypes , + + +-- ** selectMultiple #attr:selectMultiple# +{- | Whether the file chooser should allow selecting multiple +files. See +'GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetSelectMultiple' for +more details. +-} +#if ENABLE_OVERLOADING + FileChooserRequestSelectMultiplePropertyInfo, +#endif +#if ENABLE_OVERLOADING + fileChooserRequestSelectMultiple , +#endif + getFileChooserRequestSelectMultiple , + + +-- ** selectedFiles #attr:selectedFiles# +{- | A 'Nothing'-terminated array of strings containing the list of +selected files associated to the current request. See +'GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetSelectedFiles' for more details. +-} +#if ENABLE_OVERLOADING + FileChooserRequestSelectedFilesPropertyInfo, +#endif +#if ENABLE_OVERLOADING + fileChooserRequestSelectedFiles , +#endif + getFileChooserRequestSelectedFiles , + + + + + ) 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.Gtk.Objects.FileFilter as Gtk.FileFilter + +-- | Memory-managed wrapper type. +newtype FileChooserRequest = FileChooserRequest (ManagedPtr FileChooserRequest) +foreign import ccall "webkit_file_chooser_request_get_type" + c_webkit_file_chooser_request_get_type :: IO GType + +instance GObject FileChooserRequest where + gobjectType = c_webkit_file_chooser_request_get_type + + +-- | Type class for types which can be safely cast to `FileChooserRequest`, for instance with `toFileChooserRequest`. +class (GObject o, O.IsDescendantOf FileChooserRequest o) => IsFileChooserRequest o +instance (GObject o, O.IsDescendantOf FileChooserRequest o) => IsFileChooserRequest o + +instance O.HasParentTypes FileChooserRequest +type instance O.ParentTypes FileChooserRequest = '[GObject.Object.Object] + +-- | Cast to `FileChooserRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFileChooserRequest :: (MonadIO m, IsFileChooserRequest o) => o -> m FileChooserRequest +toFileChooserRequest = liftIO . unsafeCastTo FileChooserRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `FileChooserRequest`. +noFileChooserRequest :: Maybe FileChooserRequest +noFileChooserRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFileChooserRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveFileChooserRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFileChooserRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFileChooserRequestMethod "cancel" o = FileChooserRequestCancelMethodInfo + ResolveFileChooserRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFileChooserRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFileChooserRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFileChooserRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFileChooserRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFileChooserRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFileChooserRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFileChooserRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFileChooserRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFileChooserRequestMethod "selectFiles" o = FileChooserRequestSelectFilesMethodInfo + ResolveFileChooserRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFileChooserRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFileChooserRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFileChooserRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFileChooserRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFileChooserRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFileChooserRequestMethod "getMimeTypes" o = FileChooserRequestGetMimeTypesMethodInfo + ResolveFileChooserRequestMethod "getMimeTypesFilter" o = FileChooserRequestGetMimeTypesFilterMethodInfo + ResolveFileChooserRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFileChooserRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFileChooserRequestMethod "getSelectMultiple" o = FileChooserRequestGetSelectMultipleMethodInfo + ResolveFileChooserRequestMethod "getSelectedFiles" o = FileChooserRequestGetSelectedFilesMethodInfo + ResolveFileChooserRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFileChooserRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFileChooserRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFileChooserRequestMethod t FileChooserRequest, O.MethodInfo info FileChooserRequest p) => OL.IsLabel t (FileChooserRequest -> 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 + +-- VVV Prop "filter" + -- Type: TInterface (Name {namespace = "Gtk", name = "FileFilter"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@filter@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileChooserRequest #filter +@ +-} +getFileChooserRequestFilter :: (MonadIO m, IsFileChooserRequest o) => o -> m (Maybe Gtk.FileFilter.FileFilter) +getFileChooserRequestFilter obj = liftIO $ B.Properties.getObjectPropertyObject obj "filter" Gtk.FileFilter.FileFilter + +#if ENABLE_OVERLOADING +data FileChooserRequestFilterPropertyInfo +instance AttrInfo FileChooserRequestFilterPropertyInfo where + type AttrAllowedOps FileChooserRequestFilterPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileChooserRequestFilterPropertyInfo = (~) () + type AttrBaseTypeConstraint FileChooserRequestFilterPropertyInfo = IsFileChooserRequest + type AttrGetType FileChooserRequestFilterPropertyInfo = (Maybe Gtk.FileFilter.FileFilter) + type AttrLabel FileChooserRequestFilterPropertyInfo = "filter" + type AttrOrigin FileChooserRequestFilterPropertyInfo = FileChooserRequest + attrGet _ = getFileChooserRequestFilter + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "mime-types" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@mime-types@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileChooserRequest #mimeTypes +@ +-} +getFileChooserRequestMimeTypes :: (MonadIO m, IsFileChooserRequest o) => o -> m [T.Text] +getFileChooserRequestMimeTypes obj = liftIO $ checkUnexpectedNothing "getFileChooserRequestMimeTypes" $ B.Properties.getObjectPropertyStringArray obj "mime-types" + +#if ENABLE_OVERLOADING +data FileChooserRequestMimeTypesPropertyInfo +instance AttrInfo FileChooserRequestMimeTypesPropertyInfo where + type AttrAllowedOps FileChooserRequestMimeTypesPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileChooserRequestMimeTypesPropertyInfo = (~) () + type AttrBaseTypeConstraint FileChooserRequestMimeTypesPropertyInfo = IsFileChooserRequest + type AttrGetType FileChooserRequestMimeTypesPropertyInfo = [T.Text] + type AttrLabel FileChooserRequestMimeTypesPropertyInfo = "mime-types" + type AttrOrigin FileChooserRequestMimeTypesPropertyInfo = FileChooserRequest + attrGet _ = getFileChooserRequestMimeTypes + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "select-multiple" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@select-multiple@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileChooserRequest #selectMultiple +@ +-} +getFileChooserRequestSelectMultiple :: (MonadIO m, IsFileChooserRequest o) => o -> m Bool +getFileChooserRequestSelectMultiple obj = liftIO $ B.Properties.getObjectPropertyBool obj "select-multiple" + +#if ENABLE_OVERLOADING +data FileChooserRequestSelectMultiplePropertyInfo +instance AttrInfo FileChooserRequestSelectMultiplePropertyInfo where + type AttrAllowedOps FileChooserRequestSelectMultiplePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FileChooserRequestSelectMultiplePropertyInfo = (~) () + type AttrBaseTypeConstraint FileChooserRequestSelectMultiplePropertyInfo = IsFileChooserRequest + type AttrGetType FileChooserRequestSelectMultiplePropertyInfo = Bool + type AttrLabel FileChooserRequestSelectMultiplePropertyInfo = "select-multiple" + type AttrOrigin FileChooserRequestSelectMultiplePropertyInfo = FileChooserRequest + attrGet _ = getFileChooserRequestSelectMultiple + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "selected-files" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@selected-files@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileChooserRequest #selectedFiles +@ +-} +getFileChooserRequestSelectedFiles :: (MonadIO m, IsFileChooserRequest o) => o -> m (Maybe [T.Text]) +getFileChooserRequestSelectedFiles obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "selected-files" + +#if ENABLE_OVERLOADING +data FileChooserRequestSelectedFilesPropertyInfo +instance AttrInfo FileChooserRequestSelectedFilesPropertyInfo where + type AttrAllowedOps FileChooserRequestSelectedFilesPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileChooserRequestSelectedFilesPropertyInfo = (~) () + type AttrBaseTypeConstraint FileChooserRequestSelectedFilesPropertyInfo = IsFileChooserRequest + type AttrGetType FileChooserRequestSelectedFilesPropertyInfo = (Maybe [T.Text]) + type AttrLabel FileChooserRequestSelectedFilesPropertyInfo = "selected-files" + type AttrOrigin FileChooserRequestSelectedFilesPropertyInfo = FileChooserRequest + attrGet _ = getFileChooserRequestSelectedFiles + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FileChooserRequest +type instance O.AttributeList FileChooserRequest = FileChooserRequestAttributeList +type FileChooserRequestAttributeList = ('[ '("filter", FileChooserRequestFilterPropertyInfo), '("mimeTypes", FileChooserRequestMimeTypesPropertyInfo), '("selectMultiple", FileChooserRequestSelectMultiplePropertyInfo), '("selectedFiles", FileChooserRequestSelectedFilesPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +fileChooserRequestFilter :: AttrLabelProxy "filter" +fileChooserRequestFilter = AttrLabelProxy + +fileChooserRequestMimeTypes :: AttrLabelProxy "mimeTypes" +fileChooserRequestMimeTypes = AttrLabelProxy + +fileChooserRequestSelectMultiple :: AttrLabelProxy "selectMultiple" +fileChooserRequestSelectMultiple = AttrLabelProxy + +fileChooserRequestSelectedFiles :: AttrLabelProxy "selectedFiles" +fileChooserRequestSelectedFiles = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FileChooserRequest = FileChooserRequestSignalList +type FileChooserRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FileChooserRequest::cancel +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_cancel" webkit_file_chooser_request_cancel :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + IO () + +{- | +Ask WebKit to cancel the request. It\'s important to do this in case +no selection has been made in the client, otherwise the request +won\'t be properly completed and the browser will keep the request +pending forever, which might cause the browser to hang. +-} +fileChooserRequestCancel :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> m () +fileChooserRequestCancel request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_file_chooser_request_cancel request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data FileChooserRequestCancelMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestCancelMethodInfo a signature where + overloadedMethod _ = fileChooserRequestCancel + +#endif + +-- method FileChooserRequest::get_mime_types +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_get_mime_types" webkit_file_chooser_request_get_mime_types :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + IO (Ptr CString) + +{- | +Get the list of MIME types the file chooser dialog should handle, +in the format specified in RFC 2046 for \"media types\". Its contents +depend on the value of the \'accept\' attribute for HTML input +elements. This function should normally be called before presenting +the file chooser dialog to the user, to decide whether to allow the +user to select multiple files at once or only one. +-} +fileChooserRequestGetMimeTypes :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> m [T.Text] + {- ^ __Returns:__ a +'Nothing'-terminated array of strings if a list of accepted MIME types +is defined or 'Nothing' otherwise, meaning that any MIME type should be +accepted. This array and its contents are owned by WebKit and +should not be modified or freed. -} +fileChooserRequestGetMimeTypes request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_file_chooser_request_get_mime_types request' + checkUnexpectedReturnNULL "fileChooserRequestGetMimeTypes" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data FileChooserRequestGetMimeTypesMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestGetMimeTypesMethodInfo a signature where + overloadedMethod _ = fileChooserRequestGetMimeTypes + +#endif + +-- method FileChooserRequest::get_mime_types_filter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "FileFilter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_get_mime_types_filter" webkit_file_chooser_request_get_mime_types_filter :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + IO (Ptr Gtk.FileFilter.FileFilter) + +{- | +Get the filter currently associated with the request, ready to be +used by 'GI.Gtk.Interfaces.FileChooser.FileChooser'. This function should normally be called +before presenting the file chooser dialog to the user, to decide +whether to apply a filter so the user would not be allowed to +select files with other MIME types. + +See 'GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetMimeTypes' if you are +interested in getting the list of accepted MIME types. +-} +fileChooserRequestGetMimeTypesFilter :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> m (Maybe Gtk.FileFilter.FileFilter) + {- ^ __Returns:__ a 'GI.Gtk.Objects.FileFilter.FileFilter' if a list of accepted +MIME types is defined or 'Nothing' otherwise. The returned object is +owned by WebKit should not be modified or freed. -} +fileChooserRequestGetMimeTypesFilter request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_file_chooser_request_get_mime_types_filter request' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.FileFilter.FileFilter) result' + return result'' + touchManagedPtr request + return maybeResult + +#if ENABLE_OVERLOADING +data FileChooserRequestGetMimeTypesFilterMethodInfo +instance (signature ~ (m (Maybe Gtk.FileFilter.FileFilter)), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestGetMimeTypesFilterMethodInfo a signature where + overloadedMethod _ = fileChooserRequestGetMimeTypesFilter + +#endif + +-- method FileChooserRequest::get_select_multiple +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_get_select_multiple" webkit_file_chooser_request_get_select_multiple :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + IO CInt + +{- | +Determine whether the file chooser associated to this +'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' should allow selecting multiple files, +which depends on the HTML input element having a \'multiple\' +attribute defined. +-} +fileChooserRequestGetSelectMultiple :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> m Bool + {- ^ __Returns:__ 'True' if the file chooser should allow selecting multiple files or 'False' otherwise. -} +fileChooserRequestGetSelectMultiple request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_file_chooser_request_get_select_multiple request' + let result' = (/= 0) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data FileChooserRequestGetSelectMultipleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestGetSelectMultipleMethodInfo a signature where + overloadedMethod _ = fileChooserRequestGetSelectMultiple + +#endif + +-- method FileChooserRequest::get_selected_files +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_get_selected_files" webkit_file_chooser_request_get_selected_files :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + IO (Ptr CString) + +{- | +Get the list of selected files currently associated to the +request. Initially, the return value of this method contains any +files selected in previous file chooser requests for this HTML +input element. Once webkit_file_chooser_request_select_files, the +value will reflect whatever files are given. + +This function should normally be called only before presenting the +file chooser dialog to the user, to decide whether to perform some +extra action, like pre-selecting the files from a previous request. +-} +fileChooserRequestGetSelectedFiles :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a +'Nothing'-terminated array of strings if there are selected files +associated with the request or 'Nothing' otherwise. This array and its +contents are owned by WebKit and should not be modified or +freed. -} +fileChooserRequestGetSelectedFiles request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_file_chooser_request_get_selected_files request' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr request + return maybeResult + +#if ENABLE_OVERLOADING +data FileChooserRequestGetSelectedFilesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestGetSelectedFilesMethodInfo a signature where + overloadedMethod _ = fileChooserRequestGetSelectedFiles + +#endif + +-- method FileChooserRequest::select_files +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFileChooserRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "files", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a\n%NULL-terminated array of strings, containing paths to local files.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_file_chooser_request_select_files" webkit_file_chooser_request_select_files :: + Ptr FileChooserRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FileChooserRequest"}) + Ptr CString -> -- files : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Ask WebKit to select local files for upload and complete the +request. +-} +fileChooserRequestSelectFiles :: + (B.CallStack.HasCallStack, MonadIO m, IsFileChooserRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> [T.Text] + {- ^ /@files@/: a +'Nothing'-terminated array of strings, containing paths to local files. -} + -> m () +fileChooserRequestSelectFiles request files = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + files' <- packZeroTerminatedUTF8CArray files + webkit_file_chooser_request_select_files request' files' + touchManagedPtr request + mapZeroTerminatedCArray freeMem files' + freeMem files' + return () + +#if ENABLE_OVERLOADING +data FileChooserRequestSelectFilesMethodInfo +instance (signature ~ ([T.Text] -> m ()), MonadIO m, IsFileChooserRequest a) => O.MethodInfo FileChooserRequestSelectFilesMethodInfo a signature where + overloadedMethod _ = fileChooserRequestSelectFiles + +#endif + + diff --git a/GI/WebKit2/Objects/FileChooserRequest.hs-boot b/GI/WebKit2/Objects/FileChooserRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FileChooserRequest.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.FileChooserRequest 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 + +newtype FileChooserRequest = FileChooserRequest (ManagedPtr FileChooserRequest) +instance GObject FileChooserRequest where +class (GObject o, O.IsDescendantOf FileChooserRequest o) => IsFileChooserRequest o +instance (GObject o, O.IsDescendantOf FileChooserRequest o) => IsFileChooserRequest o +instance O.HasParentTypes FileChooserRequest +#if ENABLE_OVERLOADING +data FileChooserRequestFilterPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestMimeTypesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestSelectMultiplePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestSelectedFilesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestCancelMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestGetMimeTypesMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestGetMimeTypesFilterMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestGetSelectMultipleMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestGetSelectedFilesMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileChooserRequestSelectFilesMethodInfo +#endif diff --git a/GI/WebKit2/Objects/FindController.hs b/GI/WebKit2/Objects/FindController.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FindController.hs @@ -0,0 +1,1053 @@ + + +{- | +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.FindController + ( + +-- * Exported types + FindController(..) , + IsFindController , + toFindController , + noFindController , + + + -- * Methods +-- ** countMatches #method:countMatches# + +#if ENABLE_OVERLOADING + FindControllerCountMatchesMethodInfo , +#endif + findControllerCountMatches , + + +-- ** getMaxMatchCount #method:getMaxMatchCount# + +#if ENABLE_OVERLOADING + FindControllerGetMaxMatchCountMethodInfo, +#endif + findControllerGetMaxMatchCount , + + +-- ** getOptions #method:getOptions# + +#if ENABLE_OVERLOADING + FindControllerGetOptionsMethodInfo , +#endif + findControllerGetOptions , + + +-- ** getSearchText #method:getSearchText# + +#if ENABLE_OVERLOADING + FindControllerGetSearchTextMethodInfo , +#endif + findControllerGetSearchText , + + +-- ** getWebView #method:getWebView# + +#if ENABLE_OVERLOADING + FindControllerGetWebViewMethodInfo , +#endif + findControllerGetWebView , + + +-- ** search #method:search# + +#if ENABLE_OVERLOADING + FindControllerSearchMethodInfo , +#endif + findControllerSearch , + + +-- ** searchFinish #method:searchFinish# + +#if ENABLE_OVERLOADING + FindControllerSearchFinishMethodInfo , +#endif + findControllerSearchFinish , + + +-- ** searchNext #method:searchNext# + +#if ENABLE_OVERLOADING + FindControllerSearchNextMethodInfo , +#endif + findControllerSearchNext , + + +-- ** searchPrevious #method:searchPrevious# + +#if ENABLE_OVERLOADING + FindControllerSearchPreviousMethodInfo , +#endif + findControllerSearchPrevious , + + + + + -- * Properties +-- ** maxMatchCount #attr:maxMatchCount# +{- | The maximum number of matches to report for a given search. +-} +#if ENABLE_OVERLOADING + FindControllerMaxMatchCountPropertyInfo , +#endif +#if ENABLE_OVERLOADING + findControllerMaxMatchCount , +#endif + getFindControllerMaxMatchCount , + + +-- ** options #attr:options# +{- | The options to be used in the search operation. +-} +#if ENABLE_OVERLOADING + FindControllerOptionsPropertyInfo , +#endif +#if ENABLE_OVERLOADING + findControllerOptions , +#endif + getFindControllerOptions , + + +-- ** text #attr:text# +{- | The current search text for this 'GI.WebKit2.Objects.FindController.FindController'. +-} +#if ENABLE_OVERLOADING + FindControllerTextPropertyInfo , +#endif +#if ENABLE_OVERLOADING + findControllerText , +#endif + getFindControllerText , + + +-- ** webView #attr:webView# +{- | The 'GI.WebKit2.Objects.WebView.WebView' this controller is associated to. +-} +#if ENABLE_OVERLOADING + FindControllerWebViewPropertyInfo , +#endif + constructFindControllerWebView , +#if ENABLE_OVERLOADING + findControllerWebView , +#endif + getFindControllerWebView , + + + + + -- * Signals +-- ** countedMatches #signal:countedMatches# + + C_FindControllerCountedMatchesCallback , + FindControllerCountedMatchesCallback , +#if ENABLE_OVERLOADING + FindControllerCountedMatchesSignalInfo , +#endif + afterFindControllerCountedMatches , + genClosure_FindControllerCountedMatches , + mk_FindControllerCountedMatchesCallback , + noFindControllerCountedMatchesCallback , + onFindControllerCountedMatches , + wrap_FindControllerCountedMatchesCallback, + + +-- ** failedToFindText #signal:failedToFindText# + + C_FindControllerFailedToFindTextCallback, + FindControllerFailedToFindTextCallback , +#if ENABLE_OVERLOADING + FindControllerFailedToFindTextSignalInfo, +#endif + afterFindControllerFailedToFindText , + genClosure_FindControllerFailedToFindText, + mk_FindControllerFailedToFindTextCallback, + noFindControllerFailedToFindTextCallback, + onFindControllerFailedToFindText , + wrap_FindControllerFailedToFindTextCallback, + + +-- ** foundText #signal:foundText# + + C_FindControllerFoundTextCallback , + FindControllerFoundTextCallback , +#if ENABLE_OVERLOADING + FindControllerFoundTextSignalInfo , +#endif + afterFindControllerFoundText , + genClosure_FindControllerFoundText , + mk_FindControllerFoundTextCallback , + noFindControllerFoundTextCallback , + onFindControllerFoundText , + wrap_FindControllerFoundTextCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView + +-- | Memory-managed wrapper type. +newtype FindController = FindController (ManagedPtr FindController) +foreign import ccall "webkit_find_controller_get_type" + c_webkit_find_controller_get_type :: IO GType + +instance GObject FindController where + gobjectType = c_webkit_find_controller_get_type + + +-- | Type class for types which can be safely cast to `FindController`, for instance with `toFindController`. +class (GObject o, O.IsDescendantOf FindController o) => IsFindController o +instance (GObject o, O.IsDescendantOf FindController o) => IsFindController o + +instance O.HasParentTypes FindController +type instance O.ParentTypes FindController = '[GObject.Object.Object] + +-- | Cast to `FindController`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFindController :: (MonadIO m, IsFindController o) => o -> m FindController +toFindController = liftIO . unsafeCastTo FindController + +-- | A convenience alias for `Nothing` :: `Maybe` `FindController`. +noFindController :: Maybe FindController +noFindController = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFindControllerMethod (t :: Symbol) (o :: *) :: * where + ResolveFindControllerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFindControllerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFindControllerMethod "countMatches" o = FindControllerCountMatchesMethodInfo + ResolveFindControllerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFindControllerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFindControllerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFindControllerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFindControllerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFindControllerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFindControllerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFindControllerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFindControllerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFindControllerMethod "search" o = FindControllerSearchMethodInfo + ResolveFindControllerMethod "searchFinish" o = FindControllerSearchFinishMethodInfo + ResolveFindControllerMethod "searchNext" o = FindControllerSearchNextMethodInfo + ResolveFindControllerMethod "searchPrevious" o = FindControllerSearchPreviousMethodInfo + ResolveFindControllerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFindControllerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFindControllerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFindControllerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFindControllerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFindControllerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFindControllerMethod "getMaxMatchCount" o = FindControllerGetMaxMatchCountMethodInfo + ResolveFindControllerMethod "getOptions" o = FindControllerGetOptionsMethodInfo + ResolveFindControllerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFindControllerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFindControllerMethod "getSearchText" o = FindControllerGetSearchTextMethodInfo + ResolveFindControllerMethod "getWebView" o = FindControllerGetWebViewMethodInfo + ResolveFindControllerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFindControllerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFindControllerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFindControllerMethod t FindController, O.MethodInfo info FindController p) => OL.IsLabel t (FindController -> 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 FindController::counted-matches +{- | +This signal is emitted when the 'GI.WebKit2.Objects.FindController.FindController' has +counted the number of matches for a given text after a call +to 'GI.WebKit2.Objects.FindController.findControllerCountMatches'. +-} +type FindControllerCountedMatchesCallback = + Word32 + {- ^ /@matchCount@/: the number of matches of the search text -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerCountedMatchesCallback`@. +noFindControllerCountedMatchesCallback :: Maybe FindControllerCountedMatchesCallback +noFindControllerCountedMatchesCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_FindControllerCountedMatchesCallback = + Ptr () -> -- object + Word32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_FindControllerCountedMatchesCallback`. +foreign import ccall "wrapper" + mk_FindControllerCountedMatchesCallback :: C_FindControllerCountedMatchesCallback -> IO (FunPtr C_FindControllerCountedMatchesCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_FindControllerCountedMatches :: MonadIO m => FindControllerCountedMatchesCallback -> m (GClosure C_FindControllerCountedMatchesCallback) +genClosure_FindControllerCountedMatches cb = liftIO $ do + let cb' = wrap_FindControllerCountedMatchesCallback cb + mk_FindControllerCountedMatchesCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `FindControllerCountedMatchesCallback` into a `C_FindControllerCountedMatchesCallback`. +wrap_FindControllerCountedMatchesCallback :: + FindControllerCountedMatchesCallback -> + C_FindControllerCountedMatchesCallback +wrap_FindControllerCountedMatchesCallback _cb _ matchCount _ = do + _cb matchCount + + +{- | +Connect a signal handler for the “@counted-matches@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' findController #countedMatches callback +@ +-} +onFindControllerCountedMatches :: (IsFindController a, MonadIO m) => a -> FindControllerCountedMatchesCallback -> m SignalHandlerId +onFindControllerCountedMatches obj cb = liftIO $ do + let cb' = wrap_FindControllerCountedMatchesCallback cb + cb'' <- mk_FindControllerCountedMatchesCallback cb' + connectSignalFunPtr obj "counted-matches" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@counted-matches@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' findController #countedMatches callback +@ +-} +afterFindControllerCountedMatches :: (IsFindController a, MonadIO m) => a -> FindControllerCountedMatchesCallback -> m SignalHandlerId +afterFindControllerCountedMatches obj cb = liftIO $ do + let cb' = wrap_FindControllerCountedMatchesCallback cb + cb'' <- mk_FindControllerCountedMatchesCallback cb' + connectSignalFunPtr obj "counted-matches" cb'' SignalConnectAfter + + +-- signal FindController::failed-to-find-text +{- | +This signal is emitted when a search operation does not find +any result for the given text. It will be issued if the text +is not found asynchronously after a call to +'GI.WebKit2.Objects.FindController.findControllerSearch', 'GI.WebKit2.Objects.FindController.findControllerSearchNext' +or 'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'. +-} +type FindControllerFailedToFindTextCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerFailedToFindTextCallback`@. +noFindControllerFailedToFindTextCallback :: Maybe FindControllerFailedToFindTextCallback +noFindControllerFailedToFindTextCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_FindControllerFailedToFindTextCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_FindControllerFailedToFindTextCallback`. +foreign import ccall "wrapper" + mk_FindControllerFailedToFindTextCallback :: C_FindControllerFailedToFindTextCallback -> IO (FunPtr C_FindControllerFailedToFindTextCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_FindControllerFailedToFindText :: MonadIO m => FindControllerFailedToFindTextCallback -> m (GClosure C_FindControllerFailedToFindTextCallback) +genClosure_FindControllerFailedToFindText cb = liftIO $ do + let cb' = wrap_FindControllerFailedToFindTextCallback cb + mk_FindControllerFailedToFindTextCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `FindControllerFailedToFindTextCallback` into a `C_FindControllerFailedToFindTextCallback`. +wrap_FindControllerFailedToFindTextCallback :: + FindControllerFailedToFindTextCallback -> + C_FindControllerFailedToFindTextCallback +wrap_FindControllerFailedToFindTextCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@failed-to-find-text@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' findController #failedToFindText callback +@ +-} +onFindControllerFailedToFindText :: (IsFindController a, MonadIO m) => a -> FindControllerFailedToFindTextCallback -> m SignalHandlerId +onFindControllerFailedToFindText obj cb = liftIO $ do + let cb' = wrap_FindControllerFailedToFindTextCallback cb + cb'' <- mk_FindControllerFailedToFindTextCallback cb' + connectSignalFunPtr obj "failed-to-find-text" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@failed-to-find-text@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' findController #failedToFindText callback +@ +-} +afterFindControllerFailedToFindText :: (IsFindController a, MonadIO m) => a -> FindControllerFailedToFindTextCallback -> m SignalHandlerId +afterFindControllerFailedToFindText obj cb = liftIO $ do + let cb' = wrap_FindControllerFailedToFindTextCallback cb + cb'' <- mk_FindControllerFailedToFindTextCallback cb' + connectSignalFunPtr obj "failed-to-find-text" cb'' SignalConnectAfter + + +-- signal FindController::found-text +{- | +This signal is emitted when a given text is found in the web +page text. It will be issued if the text is found +asynchronously after a call to 'GI.WebKit2.Objects.FindController.findControllerSearch', +'GI.WebKit2.Objects.FindController.findControllerSearchNext' or +'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'. +-} +type FindControllerFoundTextCallback = + Word32 + {- ^ /@matchCount@/: the number of matches found of the search text -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `FindControllerFoundTextCallback`@. +noFindControllerFoundTextCallback :: Maybe FindControllerFoundTextCallback +noFindControllerFoundTextCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_FindControllerFoundTextCallback = + Ptr () -> -- object + Word32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_FindControllerFoundTextCallback`. +foreign import ccall "wrapper" + mk_FindControllerFoundTextCallback :: C_FindControllerFoundTextCallback -> IO (FunPtr C_FindControllerFoundTextCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_FindControllerFoundText :: MonadIO m => FindControllerFoundTextCallback -> m (GClosure C_FindControllerFoundTextCallback) +genClosure_FindControllerFoundText cb = liftIO $ do + let cb' = wrap_FindControllerFoundTextCallback cb + mk_FindControllerFoundTextCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `FindControllerFoundTextCallback` into a `C_FindControllerFoundTextCallback`. +wrap_FindControllerFoundTextCallback :: + FindControllerFoundTextCallback -> + C_FindControllerFoundTextCallback +wrap_FindControllerFoundTextCallback _cb _ matchCount _ = do + _cb matchCount + + +{- | +Connect a signal handler for the “@found-text@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' findController #foundText callback +@ +-} +onFindControllerFoundText :: (IsFindController a, MonadIO m) => a -> FindControllerFoundTextCallback -> m SignalHandlerId +onFindControllerFoundText obj cb = liftIO $ do + let cb' = wrap_FindControllerFoundTextCallback cb + cb'' <- mk_FindControllerFoundTextCallback cb' + connectSignalFunPtr obj "found-text" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@found-text@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' findController #foundText callback +@ +-} +afterFindControllerFoundText :: (IsFindController a, MonadIO m) => a -> FindControllerFoundTextCallback -> m SignalHandlerId +afterFindControllerFoundText obj cb = liftIO $ do + let cb' = wrap_FindControllerFoundTextCallback cb + cb'' <- mk_FindControllerFoundTextCallback cb' + connectSignalFunPtr obj "found-text" cb'' SignalConnectAfter + + +-- VVV Prop "max-match-count" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@max-match-count@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' findController #maxMatchCount +@ +-} +getFindControllerMaxMatchCount :: (MonadIO m, IsFindController o) => o -> m Word32 +getFindControllerMaxMatchCount obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "max-match-count" + +#if ENABLE_OVERLOADING +data FindControllerMaxMatchCountPropertyInfo +instance AttrInfo FindControllerMaxMatchCountPropertyInfo where + type AttrAllowedOps FindControllerMaxMatchCountPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FindControllerMaxMatchCountPropertyInfo = (~) () + type AttrBaseTypeConstraint FindControllerMaxMatchCountPropertyInfo = IsFindController + type AttrGetType FindControllerMaxMatchCountPropertyInfo = Word32 + type AttrLabel FindControllerMaxMatchCountPropertyInfo = "max-match-count" + type AttrOrigin FindControllerMaxMatchCountPropertyInfo = FindController + attrGet _ = getFindControllerMaxMatchCount + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "options" + -- Type: TInterface (Name {namespace = "WebKit2", name = "FindOptions"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@options@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' findController #options +@ +-} +getFindControllerOptions :: (MonadIO m, IsFindController o) => o -> m [WebKit2.Flags.FindOptions] +getFindControllerOptions obj = liftIO $ B.Properties.getObjectPropertyFlags obj "options" + +#if ENABLE_OVERLOADING +data FindControllerOptionsPropertyInfo +instance AttrInfo FindControllerOptionsPropertyInfo where + type AttrAllowedOps FindControllerOptionsPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FindControllerOptionsPropertyInfo = (~) () + type AttrBaseTypeConstraint FindControllerOptionsPropertyInfo = IsFindController + type AttrGetType FindControllerOptionsPropertyInfo = [WebKit2.Flags.FindOptions] + type AttrLabel FindControllerOptionsPropertyInfo = "options" + type AttrOrigin FindControllerOptionsPropertyInfo = FindController + attrGet _ = getFindControllerOptions + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "text" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' findController #text +@ +-} +getFindControllerText :: (MonadIO m, IsFindController o) => o -> m (Maybe T.Text) +getFindControllerText obj = liftIO $ B.Properties.getObjectPropertyString obj "text" + +#if ENABLE_OVERLOADING +data FindControllerTextPropertyInfo +instance AttrInfo FindControllerTextPropertyInfo where + type AttrAllowedOps FindControllerTextPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FindControllerTextPropertyInfo = (~) () + type AttrBaseTypeConstraint FindControllerTextPropertyInfo = IsFindController + type AttrGetType FindControllerTextPropertyInfo = (Maybe T.Text) + type AttrLabel FindControllerTextPropertyInfo = "text" + type AttrOrigin FindControllerTextPropertyInfo = FindController + attrGet _ = getFindControllerText + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "web-view" + -- Type: TInterface (Name {namespace = "WebKit2", name = "WebView"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@web-view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' findController #webView +@ +-} +getFindControllerWebView :: (MonadIO m, IsFindController o) => o -> m WebKit2.WebView.WebView +getFindControllerWebView obj = liftIO $ checkUnexpectedNothing "getFindControllerWebView" $ B.Properties.getObjectPropertyObject obj "web-view" WebKit2.WebView.WebView + +{- | +Construct a `GValueConstruct` with valid value for the “@web-view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFindControllerWebView :: (IsFindController o, WebKit2.WebView.IsWebView a) => a -> IO (GValueConstruct o) +constructFindControllerWebView val = B.Properties.constructObjectPropertyObject "web-view" (Just val) + +#if ENABLE_OVERLOADING +data FindControllerWebViewPropertyInfo +instance AttrInfo FindControllerWebViewPropertyInfo where + type AttrAllowedOps FindControllerWebViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FindControllerWebViewPropertyInfo = WebKit2.WebView.IsWebView + type AttrBaseTypeConstraint FindControllerWebViewPropertyInfo = IsFindController + type AttrGetType FindControllerWebViewPropertyInfo = WebKit2.WebView.WebView + type AttrLabel FindControllerWebViewPropertyInfo = "web-view" + type AttrOrigin FindControllerWebViewPropertyInfo = FindController + attrGet _ = getFindControllerWebView + attrSet _ = undefined + attrConstruct _ = constructFindControllerWebView + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FindController +type instance O.AttributeList FindController = FindControllerAttributeList +type FindControllerAttributeList = ('[ '("maxMatchCount", FindControllerMaxMatchCountPropertyInfo), '("options", FindControllerOptionsPropertyInfo), '("text", FindControllerTextPropertyInfo), '("webView", FindControllerWebViewPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +findControllerMaxMatchCount :: AttrLabelProxy "maxMatchCount" +findControllerMaxMatchCount = AttrLabelProxy + +findControllerOptions :: AttrLabelProxy "options" +findControllerOptions = AttrLabelProxy + +findControllerText :: AttrLabelProxy "text" +findControllerText = AttrLabelProxy + +findControllerWebView :: AttrLabelProxy "webView" +findControllerWebView = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data FindControllerCountedMatchesSignalInfo +instance SignalInfo FindControllerCountedMatchesSignalInfo where + type HaskellCallbackType FindControllerCountedMatchesSignalInfo = FindControllerCountedMatchesCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_FindControllerCountedMatchesCallback cb + cb'' <- mk_FindControllerCountedMatchesCallback cb' + connectSignalFunPtr obj "counted-matches" cb'' connectMode + +data FindControllerFailedToFindTextSignalInfo +instance SignalInfo FindControllerFailedToFindTextSignalInfo where + type HaskellCallbackType FindControllerFailedToFindTextSignalInfo = FindControllerFailedToFindTextCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_FindControllerFailedToFindTextCallback cb + cb'' <- mk_FindControllerFailedToFindTextCallback cb' + connectSignalFunPtr obj "failed-to-find-text" cb'' connectMode + +data FindControllerFoundTextSignalInfo +instance SignalInfo FindControllerFoundTextSignalInfo where + type HaskellCallbackType FindControllerFoundTextSignalInfo = FindControllerFoundTextCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_FindControllerFoundTextCallback cb + cb'' <- mk_FindControllerFoundTextCallback cb' + connectSignalFunPtr obj "found-text" cb'' connectMode + +type instance O.SignalList FindController = FindControllerSignalList +type FindControllerSignalList = ('[ '("countedMatches", FindControllerCountedMatchesSignalInfo), '("failedToFindText", FindControllerFailedToFindTextSignalInfo), '("foundText", FindControllerFoundTextSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FindController::count_matches +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to look for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find_options", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask with the #WebKitFindOptions used in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_match_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum number of matches allowed in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_count_matches" webkit_find_controller_count_matches :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + CString -> -- search_text : TBasicType TUTF8 + Word32 -> -- find_options : TBasicType TUInt32 + Word32 -> -- max_match_count : TBasicType TUInt + IO () + +{- | +Counts the number of matches for /@searchText@/ found in the +'GI.WebKit2.Objects.WebView.WebView' with the provided /@findOptions@/. The number of +matches will be provided by the +'GI.WebKit2.Objects.FindController.FindController'::@/counted-matches/@ signal. +-} +findControllerCountMatches :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> T.Text + {- ^ /@searchText@/: the text to look for -} + -> Word32 + {- ^ /@findOptions@/: a bitmask with the 'GI.WebKit2.Flags.FindOptions' used in the search -} + -> Word32 + {- ^ /@maxMatchCount@/: the maximum number of matches allowed in the search -} + -> m () +findControllerCountMatches findController searchText findOptions maxMatchCount = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + searchText' <- textToCString searchText + webkit_find_controller_count_matches findController' searchText' findOptions maxMatchCount + touchManagedPtr findController + freeMem searchText' + return () + +#if ENABLE_OVERLOADING +data FindControllerCountMatchesMethodInfo +instance (signature ~ (T.Text -> Word32 -> Word32 -> m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerCountMatchesMethodInfo a signature where + overloadedMethod _ = findControllerCountMatches + +#endif + +-- method FindController::get_max_match_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_get_max_match_count" webkit_find_controller_get_max_match_count :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO Word32 + +{- | +Gets the maximum number of matches to report during a text +lookup. This number is passed as the last argument of +'GI.WebKit2.Objects.FindController.findControllerSearch' or +'GI.WebKit2.Objects.FindController.findControllerCountMatches'. +-} +findControllerGetMaxMatchCount :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m Word32 + {- ^ __Returns:__ the maximum number of matches to report. -} +findControllerGetMaxMatchCount findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + result <- webkit_find_controller_get_max_match_count findController' + touchManagedPtr findController + return result + +#if ENABLE_OVERLOADING +data FindControllerGetMaxMatchCountMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetMaxMatchCountMethodInfo a signature where + overloadedMethod _ = findControllerGetMaxMatchCount + +#endif + +-- method FindController::get_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_get_options" webkit_find_controller_get_options :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO Word32 + +{- | +Gets a bitmask containing the 'GI.WebKit2.Flags.FindOptions' associated with +the current search. +-} +findControllerGetOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m Word32 + {- ^ __Returns:__ a bitmask containing the 'GI.WebKit2.Flags.FindOptions' associated +with the current search. -} +findControllerGetOptions findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + result <- webkit_find_controller_get_options findController' + touchManagedPtr findController + return result + +#if ENABLE_OVERLOADING +data FindControllerGetOptionsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetOptionsMethodInfo a signature where + overloadedMethod _ = findControllerGetOptions + +#endif + +-- method FindController::get_search_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", 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_find_controller_get_search_text" webkit_find_controller_get_search_text :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO CString + +{- | +Gets the text that /@findController@/ is currently searching +for. This text is passed to either +'GI.WebKit2.Objects.FindController.findControllerSearch' or +'GI.WebKit2.Objects.FindController.findControllerCountMatches'. +-} +findControllerGetSearchText :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m T.Text + {- ^ __Returns:__ the text to look for in the 'GI.WebKit2.Objects.WebView.WebView'. -} +findControllerGetSearchText findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + result <- webkit_find_controller_get_search_text findController' + checkUnexpectedReturnNULL "findControllerGetSearchText" result + result' <- cstringToText result + touchManagedPtr findController + return result' + +#if ENABLE_OVERLOADING +data FindControllerGetSearchTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetSearchTextMethodInfo a signature where + overloadedMethod _ = findControllerGetSearchText + +#endif + +-- method FindController::get_web_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_get_web_view" webkit_find_controller_get_web_view :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO (Ptr WebKit2.WebView.WebView) + +{- | +Gets the 'GI.WebKit2.Objects.WebView.WebView' this find controller is associated to. Do +not dereference the returned instance as it belongs to the +'GI.WebKit2.Objects.FindController.FindController'. +-} +findControllerGetWebView :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m WebKit2.WebView.WebView + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebView.WebView'. -} +findControllerGetWebView findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + result <- webkit_find_controller_get_web_view findController' + checkUnexpectedReturnNULL "findControllerGetWebView" result + result' <- (newObject WebKit2.WebView.WebView) result + touchManagedPtr findController + return result' + +#if ENABLE_OVERLOADING +data FindControllerGetWebViewMethodInfo +instance (signature ~ (m WebKit2.WebView.WebView), MonadIO m, IsFindController a) => O.MethodInfo FindControllerGetWebViewMethodInfo a signature where + overloadedMethod _ = findControllerGetWebView + +#endif + +-- method FindController::search +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to look for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find_options", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask with the #WebKitFindOptions used in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_match_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum number of matches allowed in the search", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_search" webkit_find_controller_search :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + CString -> -- search_text : TBasicType TUTF8 + Word32 -> -- find_options : TBasicType TUInt32 + Word32 -> -- max_match_count : TBasicType TUInt + IO () + +{- | +Looks for /@searchText@/ in the 'GI.WebKit2.Objects.WebView.WebView' associated with +/@findController@/ since the beginning of the document highlighting +up to /@maxMatchCount@/ matches. The outcome of the search will be +asynchronously provided by the 'GI.WebKit2.Objects.FindController.FindController'::@/found-text/@ +and 'GI.WebKit2.Objects.FindController.FindController'::@/failed-to-find-text/@ signals. + +To look for the next or previous occurrences of the same text +with the same find options use 'GI.WebKit2.Objects.FindController.findControllerSearchNext' +and\/or 'GI.WebKit2.Objects.FindController.findControllerSearchPrevious'. The +'GI.WebKit2.Objects.FindController.FindController' will use the same text and options for the +following searches unless they are modified by another call to this +method. + +Note that if the number of matches is higher than /@maxMatchCount@/ +then 'GI.WebKit2.Objects.FindController.FindController'::@/found-text/@ will report @/G_MAXUINT/@ matches +instead of the actual number. + +Callers should call 'GI.WebKit2.Objects.FindController.findControllerSearchFinish' to +finish the current search operation. +-} +findControllerSearch :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> T.Text + {- ^ /@searchText@/: the text to look for -} + -> Word32 + {- ^ /@findOptions@/: a bitmask with the 'GI.WebKit2.Flags.FindOptions' used in the search -} + -> Word32 + {- ^ /@maxMatchCount@/: the maximum number of matches allowed in the search -} + -> m () +findControllerSearch findController searchText findOptions maxMatchCount = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + searchText' <- textToCString searchText + webkit_find_controller_search findController' searchText' findOptions maxMatchCount + touchManagedPtr findController + freeMem searchText' + return () + +#if ENABLE_OVERLOADING +data FindControllerSearchMethodInfo +instance (signature ~ (T.Text -> Word32 -> Word32 -> m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchMethodInfo a signature where + overloadedMethod _ = findControllerSearch + +#endif + +-- method FindController::search_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_search_finish" webkit_find_controller_search_finish :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO () + +{- | +Finishes a find operation started by +'GI.WebKit2.Objects.FindController.findControllerSearch'. It will basically unhighlight +every text match found. + +This method will be typically called when the search UI is +closed\/hidden by the client application. +-} +findControllerSearchFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: a 'GI.WebKit2.Objects.FindController.FindController' -} + -> m () +findControllerSearchFinish findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + webkit_find_controller_search_finish findController' + touchManagedPtr findController + return () + +#if ENABLE_OVERLOADING +data FindControllerSearchFinishMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchFinishMethodInfo a signature where + overloadedMethod _ = findControllerSearchFinish + +#endif + +-- method FindController::search_next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_search_next" webkit_find_controller_search_next :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO () + +{- | +Looks for the next occurrence of the search text. + +Calling this method before 'GI.WebKit2.Objects.FindController.findControllerSearch' or +'GI.WebKit2.Objects.FindController.findControllerCountMatches' is a programming error. +-} +findControllerSearchNext :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m () +findControllerSearchNext findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + webkit_find_controller_search_next findController' + touchManagedPtr findController + return () + +#if ENABLE_OVERLOADING +data FindControllerSearchNextMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchNextMethodInfo a signature where + overloadedMethod _ = findControllerSearchNext + +#endif + +-- method FindController::search_previous +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "find_controller", argType = TInterface (Name {namespace = "WebKit2", name = "FindController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitFindController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_find_controller_search_previous" webkit_find_controller_search_previous :: + Ptr FindController -> -- find_controller : TInterface (Name {namespace = "WebKit2", name = "FindController"}) + IO () + +{- | +Looks for the previous occurrence of the search text. + +Calling this method before 'GI.WebKit2.Objects.FindController.findControllerSearch' or +'GI.WebKit2.Objects.FindController.findControllerCountMatches' is a programming error. +-} +findControllerSearchPrevious :: + (B.CallStack.HasCallStack, MonadIO m, IsFindController a) => + a + {- ^ /@findController@/: the 'GI.WebKit2.Objects.FindController.FindController' -} + -> m () +findControllerSearchPrevious findController = liftIO $ do + findController' <- unsafeManagedPtrCastPtr findController + webkit_find_controller_search_previous findController' + touchManagedPtr findController + return () + +#if ENABLE_OVERLOADING +data FindControllerSearchPreviousMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFindController a) => O.MethodInfo FindControllerSearchPreviousMethodInfo a signature where + overloadedMethod _ = findControllerSearchPrevious + +#endif + + diff --git a/GI/WebKit2/Objects/FindController.hs-boot b/GI/WebKit2/Objects/FindController.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FindController.hs-boot @@ -0,0 +1,77 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.FindController 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 + +newtype FindController = FindController (ManagedPtr FindController) +instance GObject FindController where +class (GObject o, O.IsDescendantOf FindController o) => IsFindController o +instance (GObject o, O.IsDescendantOf FindController o) => IsFindController o +instance O.HasParentTypes FindController +#if ENABLE_OVERLOADING +data FindControllerMaxMatchCountPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerOptionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerTextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerWebViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerCountedMatchesSignalInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerFailedToFindTextSignalInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerFoundTextSignalInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerCountMatchesMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerGetMaxMatchCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerGetOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerGetSearchTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerGetWebViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerSearchMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerSearchFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerSearchNextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FindControllerSearchPreviousMethodInfo +#endif diff --git a/GI/WebKit2/Objects/FormSubmissionRequest.hs b/GI/WebKit2/Objects/FormSubmissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FormSubmissionRequest.hs @@ -0,0 +1,283 @@ + + +{- | +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.FormSubmissionRequest + ( + +-- * Exported types + FormSubmissionRequest(..) , + IsFormSubmissionRequest , + toFormSubmissionRequest , + noFormSubmissionRequest , + + + -- * Methods +-- ** getTextFields #method:getTextFields# + +#if ENABLE_OVERLOADING + FormSubmissionRequestGetTextFieldsMethodInfo, +#endif + formSubmissionRequestGetTextFields , + + +-- ** listTextFields #method:listTextFields# + +#if ENABLE_OVERLOADING + FormSubmissionRequestListTextFieldsMethodInfo, +#endif + formSubmissionRequestListTextFields , + + +-- ** submit #method:submit# + +#if ENABLE_OVERLOADING + FormSubmissionRequestSubmitMethodInfo , +#endif + formSubmissionRequestSubmit , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype FormSubmissionRequest = FormSubmissionRequest (ManagedPtr FormSubmissionRequest) +foreign import ccall "webkit_form_submission_request_get_type" + c_webkit_form_submission_request_get_type :: IO GType + +instance GObject FormSubmissionRequest where + gobjectType = c_webkit_form_submission_request_get_type + + +-- | Type class for types which can be safely cast to `FormSubmissionRequest`, for instance with `toFormSubmissionRequest`. +class (GObject o, O.IsDescendantOf FormSubmissionRequest o) => IsFormSubmissionRequest o +instance (GObject o, O.IsDescendantOf FormSubmissionRequest o) => IsFormSubmissionRequest o + +instance O.HasParentTypes FormSubmissionRequest +type instance O.ParentTypes FormSubmissionRequest = '[GObject.Object.Object] + +-- | Cast to `FormSubmissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFormSubmissionRequest :: (MonadIO m, IsFormSubmissionRequest o) => o -> m FormSubmissionRequest +toFormSubmissionRequest = liftIO . unsafeCastTo FormSubmissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `FormSubmissionRequest`. +noFormSubmissionRequest :: Maybe FormSubmissionRequest +noFormSubmissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFormSubmissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveFormSubmissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFormSubmissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFormSubmissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFormSubmissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFormSubmissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFormSubmissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFormSubmissionRequestMethod "listTextFields" o = FormSubmissionRequestListTextFieldsMethodInfo + ResolveFormSubmissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFormSubmissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFormSubmissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFormSubmissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFormSubmissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFormSubmissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFormSubmissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFormSubmissionRequestMethod "submit" o = FormSubmissionRequestSubmitMethodInfo + ResolveFormSubmissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFormSubmissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFormSubmissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFormSubmissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFormSubmissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFormSubmissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFormSubmissionRequestMethod "getTextFields" o = FormSubmissionRequestGetTextFieldsMethodInfo + ResolveFormSubmissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFormSubmissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFormSubmissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFormSubmissionRequestMethod t FormSubmissionRequest, O.MethodInfo info FormSubmissionRequest p) => OL.IsLabel t (FormSubmissionRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FormSubmissionRequest +type instance O.AttributeList FormSubmissionRequest = FormSubmissionRequestAttributeList +type FormSubmissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FormSubmissionRequest = FormSubmissionRequestSignalList +type FormSubmissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FormSubmissionRequest::get_text_fields +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFormSubmissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGHash (TBasicType TPtr) (TBasicType TPtr)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_form_submission_request_get_text_fields" webkit_form_submission_request_get_text_fields :: + Ptr FormSubmissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}) + IO (Ptr (GHashTable (Ptr ()) (Ptr ()))) + +{-# DEPRECATED formSubmissionRequestGetTextFields ["(Since version 2.20.)","Use 'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestListTextFields' instead."] #-} +{- | +Get a 'GI.GLib.Structs.HashTable.HashTable' with the values of the text fields contained in the form +associated to /@request@/. Note that fields will be missing if the form +contains multiple text input elements with the same name, so this +function does not reliably return all text fields. +-} +formSubmissionRequestGetTextFields :: + (B.CallStack.HasCallStack, MonadIO m, IsFormSubmissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' -} + -> m (Maybe (Map.Map (Ptr ()) (Ptr ()))) + {- ^ __Returns:__ a 'GI.GLib.Structs.HashTable.HashTable' with the form + text fields, or 'Nothing' if the form doesn\'t contain text fields. -} +formSubmissionRequestGetTextFields request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_form_submission_request_get_text_fields request' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackGHashTable result' + let result''' = mapFirst ptrUnpackPtr result'' + let result'''' = mapSecond ptrUnpackPtr result''' + let result''''' = Map.fromList result'''' + return result''''' + touchManagedPtr request + return maybeResult + +#if ENABLE_OVERLOADING +data FormSubmissionRequestGetTextFieldsMethodInfo +instance (signature ~ (m (Maybe (Map.Map (Ptr ()) (Ptr ())))), MonadIO m, IsFormSubmissionRequest a) => O.MethodInfo FormSubmissionRequestGetTextFieldsMethodInfo a signature where + overloadedMethod _ = formSubmissionRequestGetTextFields + +#endif + +-- method FormSubmissionRequest::list_text_fields +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFormSubmissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_names", argType = TPtrArray (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n names of the text fields in the form", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_values", argType = TPtrArray (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n values of the text fields in the form", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_form_submission_request_list_text_fields" webkit_form_submission_request_list_text_fields :: + Ptr FormSubmissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}) + Ptr (Ptr (GPtrArray CString)) -> -- field_names : TPtrArray (TBasicType TUTF8) + Ptr (Ptr (GPtrArray CString)) -> -- field_values : TPtrArray (TBasicType TUTF8) + IO CInt + +{- | +Get lists with the names and values of the text fields contained in +the form associated to /@request@/. Note that names and values may be +'Nothing'. + +If this function returns 'False', then both /@fieldNames@/ and +/@fieldValues@/ will be empty. + +/Since: 2.20/ +-} +formSubmissionRequestListTextFields :: + (B.CallStack.HasCallStack, MonadIO m, IsFormSubmissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' -} + -> m ((Bool, [T.Text], [T.Text])) + {- ^ __Returns:__ 'True' if the form contains text fields, or 'False' otherwise -} +formSubmissionRequestListTextFields request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + fieldNames <- allocMem :: IO (Ptr (Ptr (GPtrArray CString))) + fieldValues <- allocMem :: IO (Ptr (Ptr (GPtrArray CString))) + result <- webkit_form_submission_request_list_text_fields request' fieldNames fieldValues + let result' = (/= 0) result + fieldNames' <- peek fieldNames + fieldNames'' <- unpackGPtrArray fieldNames' + fieldNames''' <- mapM cstringToText fieldNames'' + fieldValues' <- peek fieldValues + fieldValues'' <- unpackGPtrArray fieldValues' + fieldValues''' <- mapM cstringToText fieldValues'' + touchManagedPtr request + freeMem fieldNames + freeMem fieldValues + return (result', fieldNames''', fieldValues''') + +#if ENABLE_OVERLOADING +data FormSubmissionRequestListTextFieldsMethodInfo +instance (signature ~ (m ((Bool, [T.Text], [T.Text]))), MonadIO m, IsFormSubmissionRequest a) => O.MethodInfo FormSubmissionRequestListTextFieldsMethodInfo a signature where + overloadedMethod _ = formSubmissionRequestListTextFields + +#endif + +-- method FormSubmissionRequest::submit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitFormSubmissionRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_form_submission_request_submit" webkit_form_submission_request_submit :: + Ptr FormSubmissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "FormSubmissionRequest"}) + IO () + +{- | +Continue the form submission. +-} +formSubmissionRequestSubmit :: + (B.CallStack.HasCallStack, MonadIO m, IsFormSubmissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' -} + -> m () +formSubmissionRequestSubmit request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + webkit_form_submission_request_submit request' + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data FormSubmissionRequestSubmitMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFormSubmissionRequest a) => O.MethodInfo FormSubmissionRequestSubmitMethodInfo a signature where + overloadedMethod _ = formSubmissionRequestSubmit + +#endif + + diff --git a/GI/WebKit2/Objects/FormSubmissionRequest.hs-boot b/GI/WebKit2/Objects/FormSubmissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/FormSubmissionRequest.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.FormSubmissionRequest 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 + +newtype FormSubmissionRequest = FormSubmissionRequest (ManagedPtr FormSubmissionRequest) +instance GObject FormSubmissionRequest where +class (GObject o, O.IsDescendantOf FormSubmissionRequest o) => IsFormSubmissionRequest o +instance (GObject o, O.IsDescendantOf FormSubmissionRequest o) => IsFormSubmissionRequest o +instance O.HasParentTypes FormSubmissionRequest +#if ENABLE_OVERLOADING +data FormSubmissionRequestGetTextFieldsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormSubmissionRequestListTextFieldsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormSubmissionRequestSubmitMethodInfo +#endif diff --git a/GI/WebKit2/Objects/GeolocationPermissionRequest.hs b/GI/WebKit2/Objects/GeolocationPermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/GeolocationPermissionRequest.hs @@ -0,0 +1,124 @@ + + +{- | +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.GeolocationPermissionRequest + ( + +-- * Exported types + GeolocationPermissionRequest(..) , + IsGeolocationPermissionRequest , + toGeolocationPermissionRequest , + noGeolocationPermissionRequest , + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest + +-- | Memory-managed wrapper type. +newtype GeolocationPermissionRequest = GeolocationPermissionRequest (ManagedPtr GeolocationPermissionRequest) +foreign import ccall "webkit_geolocation_permission_request_get_type" + c_webkit_geolocation_permission_request_get_type :: IO GType + +instance GObject GeolocationPermissionRequest where + gobjectType = c_webkit_geolocation_permission_request_get_type + + +-- | Type class for types which can be safely cast to `GeolocationPermissionRequest`, for instance with `toGeolocationPermissionRequest`. +class (GObject o, O.IsDescendantOf GeolocationPermissionRequest o) => IsGeolocationPermissionRequest o +instance (GObject o, O.IsDescendantOf GeolocationPermissionRequest o) => IsGeolocationPermissionRequest o + +instance O.HasParentTypes GeolocationPermissionRequest +type instance O.ParentTypes GeolocationPermissionRequest = '[GObject.Object.Object, WebKit2.PermissionRequest.PermissionRequest] + +-- | Cast to `GeolocationPermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGeolocationPermissionRequest :: (MonadIO m, IsGeolocationPermissionRequest o) => o -> m GeolocationPermissionRequest +toGeolocationPermissionRequest = liftIO . unsafeCastTo GeolocationPermissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `GeolocationPermissionRequest`. +noGeolocationPermissionRequest :: Maybe GeolocationPermissionRequest +noGeolocationPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGeolocationPermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveGeolocationPermissionRequestMethod "allow" o = WebKit2.PermissionRequest.PermissionRequestAllowMethodInfo + ResolveGeolocationPermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGeolocationPermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGeolocationPermissionRequestMethod "deny" o = WebKit2.PermissionRequest.PermissionRequestDenyMethodInfo + ResolveGeolocationPermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGeolocationPermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGeolocationPermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGeolocationPermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGeolocationPermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGeolocationPermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGeolocationPermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGeolocationPermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGeolocationPermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGeolocationPermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGeolocationPermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGeolocationPermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGeolocationPermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGeolocationPermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGeolocationPermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGeolocationPermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGeolocationPermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGeolocationPermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGeolocationPermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGeolocationPermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGeolocationPermissionRequestMethod t GeolocationPermissionRequest, O.MethodInfo info GeolocationPermissionRequest p) => OL.IsLabel t (GeolocationPermissionRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GeolocationPermissionRequest +type instance O.AttributeList GeolocationPermissionRequest = GeolocationPermissionRequestAttributeList +type GeolocationPermissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList GeolocationPermissionRequest = GeolocationPermissionRequestSignalList +type GeolocationPermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/WebKit2/Objects/GeolocationPermissionRequest.hs-boot b/GI/WebKit2/Objects/GeolocationPermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/GeolocationPermissionRequest.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.GeolocationPermissionRequest 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 + +newtype GeolocationPermissionRequest = GeolocationPermissionRequest (ManagedPtr GeolocationPermissionRequest) +instance GObject GeolocationPermissionRequest where +class (GObject o, O.IsDescendantOf GeolocationPermissionRequest o) => IsGeolocationPermissionRequest o +instance (GObject o, O.IsDescendantOf GeolocationPermissionRequest o) => IsGeolocationPermissionRequest o +instance O.HasParentTypes GeolocationPermissionRequest diff --git a/GI/WebKit2/Objects/HitTestResult.hs b/GI/WebKit2/Objects/HitTestResult.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/HitTestResult.hs @@ -0,0 +1,1009 @@ + + +{- | +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.HitTestResult + ( + +-- * Exported types + HitTestResult(..) , + IsHitTestResult , + toHitTestResult , + noHitTestResult , + + + -- * Methods +-- ** contextIsEditable #method:contextIsEditable# + +#if ENABLE_OVERLOADING + HitTestResultContextIsEditableMethodInfo, +#endif + hitTestResultContextIsEditable , + + +-- ** contextIsImage #method:contextIsImage# + +#if ENABLE_OVERLOADING + HitTestResultContextIsImageMethodInfo , +#endif + hitTestResultContextIsImage , + + +-- ** contextIsLink #method:contextIsLink# + +#if ENABLE_OVERLOADING + HitTestResultContextIsLinkMethodInfo , +#endif + hitTestResultContextIsLink , + + +-- ** contextIsMedia #method:contextIsMedia# + +#if ENABLE_OVERLOADING + HitTestResultContextIsMediaMethodInfo , +#endif + hitTestResultContextIsMedia , + + +-- ** contextIsScrollbar #method:contextIsScrollbar# + +#if ENABLE_OVERLOADING + HitTestResultContextIsScrollbarMethodInfo, +#endif + hitTestResultContextIsScrollbar , + + +-- ** contextIsSelection #method:contextIsSelection# + +#if ENABLE_OVERLOADING + HitTestResultContextIsSelectionMethodInfo, +#endif + hitTestResultContextIsSelection , + + +-- ** getContext #method:getContext# + +#if ENABLE_OVERLOADING + HitTestResultGetContextMethodInfo , +#endif + hitTestResultGetContext , + + +-- ** getImageUri #method:getImageUri# + +#if ENABLE_OVERLOADING + HitTestResultGetImageUriMethodInfo , +#endif + hitTestResultGetImageUri , + + +-- ** getLinkLabel #method:getLinkLabel# + +#if ENABLE_OVERLOADING + HitTestResultGetLinkLabelMethodInfo , +#endif + hitTestResultGetLinkLabel , + + +-- ** getLinkTitle #method:getLinkTitle# + +#if ENABLE_OVERLOADING + HitTestResultGetLinkTitleMethodInfo , +#endif + hitTestResultGetLinkTitle , + + +-- ** getLinkUri #method:getLinkUri# + +#if ENABLE_OVERLOADING + HitTestResultGetLinkUriMethodInfo , +#endif + hitTestResultGetLinkUri , + + +-- ** getMediaUri #method:getMediaUri# + +#if ENABLE_OVERLOADING + HitTestResultGetMediaUriMethodInfo , +#endif + hitTestResultGetMediaUri , + + + + + -- * Properties +-- ** context #attr:context# +{- | Bitmask of 'GI.WebKit2.Flags.HitTestResultContext' flags representing +the context of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult'. +-} +#if ENABLE_OVERLOADING + HitTestResultContextPropertyInfo , +#endif + constructHitTestResultContext , + getHitTestResultContext , +#if ENABLE_OVERLOADING + hitTestResultContext , +#endif + + +-- ** imageUri #attr:imageUri# +{- | The URI of the image if flag 'GI.WebKit2.Flags.HitTestResultContextImage' +is present in 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ +-} +#if ENABLE_OVERLOADING + HitTestResultImageUriPropertyInfo , +#endif + constructHitTestResultImageUri , + getHitTestResultImageUri , +#if ENABLE_OVERLOADING + hitTestResultImageUri , +#endif + + +-- ** linkLabel #attr:linkLabel# +{- | The label of the link if flag 'GI.WebKit2.Flags.HitTestResultContextLink' +is present in 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ +-} +#if ENABLE_OVERLOADING + HitTestResultLinkLabelPropertyInfo , +#endif + constructHitTestResultLinkLabel , + getHitTestResultLinkLabel , +#if ENABLE_OVERLOADING + hitTestResultLinkLabel , +#endif + + +-- ** linkTitle #attr:linkTitle# +{- | The title of the link if flag 'GI.WebKit2.Flags.HitTestResultContextLink' +is present in 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ +-} +#if ENABLE_OVERLOADING + HitTestResultLinkTitlePropertyInfo , +#endif + constructHitTestResultLinkTitle , + getHitTestResultLinkTitle , +#if ENABLE_OVERLOADING + hitTestResultLinkTitle , +#endif + + +-- ** linkUri #attr:linkUri# +{- | The URI of the link if flag 'GI.WebKit2.Flags.HitTestResultContextLink' +is present in 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ +-} +#if ENABLE_OVERLOADING + HitTestResultLinkUriPropertyInfo , +#endif + constructHitTestResultLinkUri , + getHitTestResultLinkUri , +#if ENABLE_OVERLOADING + hitTestResultLinkUri , +#endif + + +-- ** mediaUri #attr:mediaUri# +{- | The URI of the media if flag 'GI.WebKit2.Flags.HitTestResultContextMedia' +is present in 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ +-} +#if ENABLE_OVERLOADING + HitTestResultMediaUriPropertyInfo , +#endif + constructHitTestResultMediaUri , + getHitTestResultMediaUri , +#if ENABLE_OVERLOADING + hitTestResultMediaUri , +#endif + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype HitTestResult = HitTestResult (ManagedPtr HitTestResult) +foreign import ccall "webkit_hit_test_result_get_type" + c_webkit_hit_test_result_get_type :: IO GType + +instance GObject HitTestResult where + gobjectType = c_webkit_hit_test_result_get_type + + +-- | Type class for types which can be safely cast to `HitTestResult`, for instance with `toHitTestResult`. +class (GObject o, O.IsDescendantOf HitTestResult o) => IsHitTestResult o +instance (GObject o, O.IsDescendantOf HitTestResult o) => IsHitTestResult o + +instance O.HasParentTypes HitTestResult +type instance O.ParentTypes HitTestResult = '[GObject.Object.Object] + +-- | Cast to `HitTestResult`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toHitTestResult :: (MonadIO m, IsHitTestResult o) => o -> m HitTestResult +toHitTestResult = liftIO . unsafeCastTo HitTestResult + +-- | A convenience alias for `Nothing` :: `Maybe` `HitTestResult`. +noHitTestResult :: Maybe HitTestResult +noHitTestResult = Nothing + +#if ENABLE_OVERLOADING +type family ResolveHitTestResultMethod (t :: Symbol) (o :: *) :: * where + ResolveHitTestResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveHitTestResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveHitTestResultMethod "contextIsEditable" o = HitTestResultContextIsEditableMethodInfo + ResolveHitTestResultMethod "contextIsImage" o = HitTestResultContextIsImageMethodInfo + ResolveHitTestResultMethod "contextIsLink" o = HitTestResultContextIsLinkMethodInfo + ResolveHitTestResultMethod "contextIsMedia" o = HitTestResultContextIsMediaMethodInfo + ResolveHitTestResultMethod "contextIsScrollbar" o = HitTestResultContextIsScrollbarMethodInfo + ResolveHitTestResultMethod "contextIsSelection" o = HitTestResultContextIsSelectionMethodInfo + ResolveHitTestResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveHitTestResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveHitTestResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveHitTestResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveHitTestResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveHitTestResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveHitTestResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveHitTestResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveHitTestResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveHitTestResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveHitTestResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveHitTestResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveHitTestResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveHitTestResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveHitTestResultMethod "getContext" o = HitTestResultGetContextMethodInfo + ResolveHitTestResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveHitTestResultMethod "getImageUri" o = HitTestResultGetImageUriMethodInfo + ResolveHitTestResultMethod "getLinkLabel" o = HitTestResultGetLinkLabelMethodInfo + ResolveHitTestResultMethod "getLinkTitle" o = HitTestResultGetLinkTitleMethodInfo + ResolveHitTestResultMethod "getLinkUri" o = HitTestResultGetLinkUriMethodInfo + ResolveHitTestResultMethod "getMediaUri" o = HitTestResultGetMediaUriMethodInfo + ResolveHitTestResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveHitTestResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveHitTestResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveHitTestResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveHitTestResultMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveHitTestResultMethod t HitTestResult, O.MethodInfo info HitTestResult p) => OL.IsLabel t (HitTestResult -> 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 + +-- VVV Prop "context" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@context@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #context +@ +-} +getHitTestResultContext :: (MonadIO m, IsHitTestResult o) => o -> m Word32 +getHitTestResultContext obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "context" + +{- | +Construct a `GValueConstruct` with valid value for the “@context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultContext :: (IsHitTestResult o) => Word32 -> IO (GValueConstruct o) +constructHitTestResultContext val = B.Properties.constructObjectPropertyUInt32 "context" val + +#if ENABLE_OVERLOADING +data HitTestResultContextPropertyInfo +instance AttrInfo HitTestResultContextPropertyInfo where + type AttrAllowedOps HitTestResultContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint HitTestResultContextPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint HitTestResultContextPropertyInfo = IsHitTestResult + type AttrGetType HitTestResultContextPropertyInfo = Word32 + type AttrLabel HitTestResultContextPropertyInfo = "context" + type AttrOrigin HitTestResultContextPropertyInfo = HitTestResult + attrGet _ = getHitTestResultContext + attrSet _ = undefined + attrConstruct _ = constructHitTestResultContext + attrClear _ = undefined +#endif + +-- VVV Prop "image-uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@image-uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #imageUri +@ +-} +getHitTestResultImageUri :: (MonadIO m, IsHitTestResult o) => o -> m (Maybe T.Text) +getHitTestResultImageUri obj = liftIO $ B.Properties.getObjectPropertyString obj "image-uri" + +{- | +Construct a `GValueConstruct` with valid value for the “@image-uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultImageUri :: (IsHitTestResult o) => T.Text -> IO (GValueConstruct o) +constructHitTestResultImageUri val = B.Properties.constructObjectPropertyString "image-uri" (Just val) + +#if ENABLE_OVERLOADING +data HitTestResultImageUriPropertyInfo +instance AttrInfo HitTestResultImageUriPropertyInfo where + type AttrAllowedOps HitTestResultImageUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint HitTestResultImageUriPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint HitTestResultImageUriPropertyInfo = IsHitTestResult + type AttrGetType HitTestResultImageUriPropertyInfo = (Maybe T.Text) + type AttrLabel HitTestResultImageUriPropertyInfo = "image-uri" + type AttrOrigin HitTestResultImageUriPropertyInfo = HitTestResult + attrGet _ = getHitTestResultImageUri + attrSet _ = undefined + attrConstruct _ = constructHitTestResultImageUri + attrClear _ = undefined +#endif + +-- VVV Prop "link-label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@link-label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #linkLabel +@ +-} +getHitTestResultLinkLabel :: (MonadIO m, IsHitTestResult o) => o -> m (Maybe T.Text) +getHitTestResultLinkLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "link-label" + +{- | +Construct a `GValueConstruct` with valid value for the “@link-label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultLinkLabel :: (IsHitTestResult o) => T.Text -> IO (GValueConstruct o) +constructHitTestResultLinkLabel val = B.Properties.constructObjectPropertyString "link-label" (Just val) + +#if ENABLE_OVERLOADING +data HitTestResultLinkLabelPropertyInfo +instance AttrInfo HitTestResultLinkLabelPropertyInfo where + type AttrAllowedOps HitTestResultLinkLabelPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint HitTestResultLinkLabelPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint HitTestResultLinkLabelPropertyInfo = IsHitTestResult + type AttrGetType HitTestResultLinkLabelPropertyInfo = (Maybe T.Text) + type AttrLabel HitTestResultLinkLabelPropertyInfo = "link-label" + type AttrOrigin HitTestResultLinkLabelPropertyInfo = HitTestResult + attrGet _ = getHitTestResultLinkLabel + attrSet _ = undefined + attrConstruct _ = constructHitTestResultLinkLabel + attrClear _ = undefined +#endif + +-- VVV Prop "link-title" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@link-title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #linkTitle +@ +-} +getHitTestResultLinkTitle :: (MonadIO m, IsHitTestResult o) => o -> m (Maybe T.Text) +getHitTestResultLinkTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "link-title" + +{- | +Construct a `GValueConstruct` with valid value for the “@link-title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultLinkTitle :: (IsHitTestResult o) => T.Text -> IO (GValueConstruct o) +constructHitTestResultLinkTitle val = B.Properties.constructObjectPropertyString "link-title" (Just val) + +#if ENABLE_OVERLOADING +data HitTestResultLinkTitlePropertyInfo +instance AttrInfo HitTestResultLinkTitlePropertyInfo where + type AttrAllowedOps HitTestResultLinkTitlePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint HitTestResultLinkTitlePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint HitTestResultLinkTitlePropertyInfo = IsHitTestResult + type AttrGetType HitTestResultLinkTitlePropertyInfo = (Maybe T.Text) + type AttrLabel HitTestResultLinkTitlePropertyInfo = "link-title" + type AttrOrigin HitTestResultLinkTitlePropertyInfo = HitTestResult + attrGet _ = getHitTestResultLinkTitle + attrSet _ = undefined + attrConstruct _ = constructHitTestResultLinkTitle + attrClear _ = undefined +#endif + +-- VVV Prop "link-uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@link-uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #linkUri +@ +-} +getHitTestResultLinkUri :: (MonadIO m, IsHitTestResult o) => o -> m (Maybe T.Text) +getHitTestResultLinkUri obj = liftIO $ B.Properties.getObjectPropertyString obj "link-uri" + +{- | +Construct a `GValueConstruct` with valid value for the “@link-uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultLinkUri :: (IsHitTestResult o) => T.Text -> IO (GValueConstruct o) +constructHitTestResultLinkUri val = B.Properties.constructObjectPropertyString "link-uri" (Just val) + +#if ENABLE_OVERLOADING +data HitTestResultLinkUriPropertyInfo +instance AttrInfo HitTestResultLinkUriPropertyInfo where + type AttrAllowedOps HitTestResultLinkUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint HitTestResultLinkUriPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint HitTestResultLinkUriPropertyInfo = IsHitTestResult + type AttrGetType HitTestResultLinkUriPropertyInfo = (Maybe T.Text) + type AttrLabel HitTestResultLinkUriPropertyInfo = "link-uri" + type AttrOrigin HitTestResultLinkUriPropertyInfo = HitTestResult + attrGet _ = getHitTestResultLinkUri + attrSet _ = undefined + attrConstruct _ = constructHitTestResultLinkUri + attrClear _ = undefined +#endif + +-- VVV Prop "media-uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@media-uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' hitTestResult #mediaUri +@ +-} +getHitTestResultMediaUri :: (MonadIO m, IsHitTestResult o) => o -> m (Maybe T.Text) +getHitTestResultMediaUri obj = liftIO $ B.Properties.getObjectPropertyString obj "media-uri" + +{- | +Construct a `GValueConstruct` with valid value for the “@media-uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructHitTestResultMediaUri :: (IsHitTestResult o) => T.Text -> IO (GValueConstruct o) +constructHitTestResultMediaUri val = B.Properties.constructObjectPropertyString "media-uri" (Just val) + +#if ENABLE_OVERLOADING +data HitTestResultMediaUriPropertyInfo +instance AttrInfo HitTestResultMediaUriPropertyInfo where + type AttrAllowedOps HitTestResultMediaUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint HitTestResultMediaUriPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint HitTestResultMediaUriPropertyInfo = IsHitTestResult + type AttrGetType HitTestResultMediaUriPropertyInfo = (Maybe T.Text) + type AttrLabel HitTestResultMediaUriPropertyInfo = "media-uri" + type AttrOrigin HitTestResultMediaUriPropertyInfo = HitTestResult + attrGet _ = getHitTestResultMediaUri + attrSet _ = undefined + attrConstruct _ = constructHitTestResultMediaUri + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList HitTestResult +type instance O.AttributeList HitTestResult = HitTestResultAttributeList +type HitTestResultAttributeList = ('[ '("context", HitTestResultContextPropertyInfo), '("imageUri", HitTestResultImageUriPropertyInfo), '("linkLabel", HitTestResultLinkLabelPropertyInfo), '("linkTitle", HitTestResultLinkTitlePropertyInfo), '("linkUri", HitTestResultLinkUriPropertyInfo), '("mediaUri", HitTestResultMediaUriPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +hitTestResultContext :: AttrLabelProxy "context" +hitTestResultContext = AttrLabelProxy + +hitTestResultImageUri :: AttrLabelProxy "imageUri" +hitTestResultImageUri = AttrLabelProxy + +hitTestResultLinkLabel :: AttrLabelProxy "linkLabel" +hitTestResultLinkLabel = AttrLabelProxy + +hitTestResultLinkTitle :: AttrLabelProxy "linkTitle" +hitTestResultLinkTitle = AttrLabelProxy + +hitTestResultLinkUri :: AttrLabelProxy "linkUri" +hitTestResultLinkUri = AttrLabelProxy + +hitTestResultMediaUri :: AttrLabelProxy "mediaUri" +hitTestResultMediaUri = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList HitTestResult = HitTestResultSignalList +type HitTestResultSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method HitTestResult::context_is_editable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_editable" webkit_hit_test_result_context_is_editable :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextEditable' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. +-} +hitTestResultContextIsEditable :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s an editable element at the coordinates of the /@hitTestResult@/, + or 'False' otherwise -} +hitTestResultContextIsEditable hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_editable hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsEditableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsEditableMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsEditable + +#endif + +-- method HitTestResult::context_is_image +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_image" webkit_hit_test_result_context_is_image :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextImage' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. +-} +hitTestResultContextIsImage :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s an image element in the coordinates of the Hit Test, + or 'False' otherwise -} +hitTestResultContextIsImage hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_image hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsImageMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsImageMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsImage + +#endif + +-- method HitTestResult::context_is_link +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_link" webkit_hit_test_result_context_is_link :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextLink' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. +-} +hitTestResultContextIsLink :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s a link element in the coordinates of the Hit Test, + or 'False' otherwise -} +hitTestResultContextIsLink hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_link hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsLinkMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsLinkMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsLink + +#endif + +-- method HitTestResult::context_is_media +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_media" webkit_hit_test_result_context_is_media :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextMedia' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. +-} +hitTestResultContextIsMedia :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s a media element in the coordinates of the Hit Test, + or 'False' otherwise -} +hitTestResultContextIsMedia hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_media hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsMediaMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsMediaMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsMedia + +#endif + +-- method HitTestResult::context_is_scrollbar +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_scrollbar" webkit_hit_test_result_context_is_scrollbar :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextScrollbar' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. +-} +hitTestResultContextIsScrollbar :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s a scrollbar element at the coordinates of the /@hitTestResult@/, + or 'False' otherwise -} +hitTestResultContextIsScrollbar hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_scrollbar hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsScrollbarMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsScrollbarMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsScrollbar + +#endif + +-- method HitTestResult::context_is_selection +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_context_is_selection" webkit_hit_test_result_context_is_selection :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CInt + +{- | +Gets whether 'GI.WebKit2.Flags.HitTestResultContextSelection' flag is present in +'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@. + +/Since: 2.8/ +-} +hitTestResultContextIsSelection :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Bool + {- ^ __Returns:__ 'True' if there\'s a selected element at the coordinates of the /@hitTestResult@/, + or 'False' otherwise -} +hitTestResultContextIsSelection hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_context_is_selection hitTestResult' + let result' = (/= 0) result + touchManagedPtr hitTestResult + return result' + +#if ENABLE_OVERLOADING +data HitTestResultContextIsSelectionMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultContextIsSelectionMethodInfo a signature where + overloadedMethod _ = hitTestResultContextIsSelection + +#endif + +-- method HitTestResult::get_context +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_hit_test_result_get_context" webkit_hit_test_result_get_context :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO Word32 + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/context/@ property. +-} +hitTestResultGetContext :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m Word32 + {- ^ __Returns:__ a bitmask of 'GI.WebKit2.Flags.HitTestResultContext' flags -} +hitTestResultGetContext hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_context hitTestResult' + touchManagedPtr hitTestResult + return result + +#if ENABLE_OVERLOADING +data HitTestResultGetContextMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetContextMethodInfo a signature where + overloadedMethod _ = hitTestResultGetContext + +#endif + +-- method HitTestResult::get_image_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", 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_hit_test_result_get_image_uri" webkit_hit_test_result_get_image_uri :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/image-uri/@ property. +-} +hitTestResultGetImageUri :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the URI of the image element in the coordinates of the Hit Test, + or 'Nothing' if there isn\'t an image element in /@hitTestResult@/ context -} +hitTestResultGetImageUri hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_image_uri hitTestResult' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr hitTestResult + return maybeResult + +#if ENABLE_OVERLOADING +data HitTestResultGetImageUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetImageUriMethodInfo a signature where + overloadedMethod _ = hitTestResultGetImageUri + +#endif + +-- method HitTestResult::get_link_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", 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_hit_test_result_get_link_label" webkit_hit_test_result_get_link_label :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/link-label/@ property. +-} +hitTestResultGetLinkLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the label of the link element in the coordinates of the Hit Test, + or 'Nothing' if there isn\'t a link element in /@hitTestResult@/ context or the + link element doesn\'t have a label -} +hitTestResultGetLinkLabel hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_link_label hitTestResult' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr hitTestResult + return maybeResult + +#if ENABLE_OVERLOADING +data HitTestResultGetLinkLabelMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetLinkLabelMethodInfo a signature where + overloadedMethod _ = hitTestResultGetLinkLabel + +#endif + +-- method HitTestResult::get_link_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", 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_hit_test_result_get_link_title" webkit_hit_test_result_get_link_title :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/link-title/@ property. +-} +hitTestResultGetLinkTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the title of the link element in the coordinates of the Hit Test, + or 'Nothing' if there isn\'t a link element in /@hitTestResult@/ context or the + link element doesn\'t have a title -} +hitTestResultGetLinkTitle hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_link_title hitTestResult' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr hitTestResult + return maybeResult + +#if ENABLE_OVERLOADING +data HitTestResultGetLinkTitleMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetLinkTitleMethodInfo a signature where + overloadedMethod _ = hitTestResultGetLinkTitle + +#endif + +-- method HitTestResult::get_link_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", 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_hit_test_result_get_link_uri" webkit_hit_test_result_get_link_uri :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/link-uri/@ property. +-} +hitTestResultGetLinkUri :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the URI of the link element in the coordinates of the Hit Test, + or 'Nothing' if there isn\'t a link element in /@hitTestResult@/ context -} +hitTestResultGetLinkUri hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_link_uri hitTestResult' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr hitTestResult + return maybeResult + +#if ENABLE_OVERLOADING +data HitTestResultGetLinkUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetLinkUriMethodInfo a signature where + overloadedMethod _ = hitTestResultGetLinkUri + +#endif + +-- method HitTestResult::get_media_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hit_test_result", argType = TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHitTestResult", 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_hit_test_result_get_media_uri" webkit_hit_test_result_get_media_uri :: + Ptr HitTestResult -> -- hit_test_result : TInterface (Name {namespace = "WebKit2", name = "HitTestResult"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.HitTestResult.HitTestResult':@/media-uri/@ property. +-} +hitTestResultGetMediaUri :: + (B.CallStack.HasCallStack, MonadIO m, IsHitTestResult a) => + a + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the URI of the media element in the coordinates of the Hit Test, + or 'Nothing' if there isn\'t a media element in /@hitTestResult@/ context -} +hitTestResultGetMediaUri hitTestResult = liftIO $ do + hitTestResult' <- unsafeManagedPtrCastPtr hitTestResult + result <- webkit_hit_test_result_get_media_uri hitTestResult' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr hitTestResult + return maybeResult + +#if ENABLE_OVERLOADING +data HitTestResultGetMediaUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsHitTestResult a) => O.MethodInfo HitTestResultGetMediaUriMethodInfo a signature where + overloadedMethod _ = hitTestResultGetMediaUri + +#endif + + diff --git a/GI/WebKit2/Objects/HitTestResult.hs-boot b/GI/WebKit2/Objects/HitTestResult.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/HitTestResult.hs-boot @@ -0,0 +1,83 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.HitTestResult 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 + +newtype HitTestResult = HitTestResult (ManagedPtr HitTestResult) +instance GObject HitTestResult where +class (GObject o, O.IsDescendantOf HitTestResult o) => IsHitTestResult o +instance (GObject o, O.IsDescendantOf HitTestResult o) => IsHitTestResult o +instance O.HasParentTypes HitTestResult +#if ENABLE_OVERLOADING +data HitTestResultContextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultImageUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultLinkLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultLinkTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultLinkUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultMediaUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsEditableMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsImageMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsLinkMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsMediaMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsScrollbarMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultContextIsSelectionMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetContextMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetImageUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetLinkLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetLinkTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetLinkUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data HitTestResultGetMediaUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs b/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs @@ -0,0 +1,174 @@ + + +{- | +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.InstallMissingMediaPluginsPermissionRequest + ( + +-- * Exported types + InstallMissingMediaPluginsPermissionRequest(..), + IsInstallMissingMediaPluginsPermissionRequest, + toInstallMissingMediaPluginsPermissionRequest, + noInstallMissingMediaPluginsPermissionRequest, + + + -- * Methods +-- ** getDescription #method:getDescription# + +#if ENABLE_OVERLOADING + InstallMissingMediaPluginsPermissionRequestGetDescriptionMethodInfo, +#endif + installMissingMediaPluginsPermissionRequestGetDescription, + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest + +-- | Memory-managed wrapper type. +newtype InstallMissingMediaPluginsPermissionRequest = InstallMissingMediaPluginsPermissionRequest (ManagedPtr InstallMissingMediaPluginsPermissionRequest) +foreign import ccall "webkit_install_missing_media_plugins_permission_request_get_type" + c_webkit_install_missing_media_plugins_permission_request_get_type :: IO GType + +instance GObject InstallMissingMediaPluginsPermissionRequest where + gobjectType = c_webkit_install_missing_media_plugins_permission_request_get_type + + +-- | Type class for types which can be safely cast to `InstallMissingMediaPluginsPermissionRequest`, for instance with `toInstallMissingMediaPluginsPermissionRequest`. +class (GObject o, O.IsDescendantOf InstallMissingMediaPluginsPermissionRequest o) => IsInstallMissingMediaPluginsPermissionRequest o +instance (GObject o, O.IsDescendantOf InstallMissingMediaPluginsPermissionRequest o) => IsInstallMissingMediaPluginsPermissionRequest o + +instance O.HasParentTypes InstallMissingMediaPluginsPermissionRequest +type instance O.ParentTypes InstallMissingMediaPluginsPermissionRequest = '[GObject.Object.Object, WebKit2.PermissionRequest.PermissionRequest] + +-- | Cast to `InstallMissingMediaPluginsPermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toInstallMissingMediaPluginsPermissionRequest :: (MonadIO m, IsInstallMissingMediaPluginsPermissionRequest o) => o -> m InstallMissingMediaPluginsPermissionRequest +toInstallMissingMediaPluginsPermissionRequest = liftIO . unsafeCastTo InstallMissingMediaPluginsPermissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `InstallMissingMediaPluginsPermissionRequest`. +noInstallMissingMediaPluginsPermissionRequest :: Maybe InstallMissingMediaPluginsPermissionRequest +noInstallMissingMediaPluginsPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveInstallMissingMediaPluginsPermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveInstallMissingMediaPluginsPermissionRequestMethod "allow" o = WebKit2.PermissionRequest.PermissionRequestAllowMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "deny" o = WebKit2.PermissionRequest.PermissionRequestDenyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "getDescription" o = InstallMissingMediaPluginsPermissionRequestGetDescriptionMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveInstallMissingMediaPluginsPermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveInstallMissingMediaPluginsPermissionRequestMethod t InstallMissingMediaPluginsPermissionRequest, O.MethodInfo info InstallMissingMediaPluginsPermissionRequest p) => OL.IsLabel t (InstallMissingMediaPluginsPermissionRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList InstallMissingMediaPluginsPermissionRequest +type instance O.AttributeList InstallMissingMediaPluginsPermissionRequest = InstallMissingMediaPluginsPermissionRequestAttributeList +type InstallMissingMediaPluginsPermissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList InstallMissingMediaPluginsPermissionRequest = InstallMissingMediaPluginsPermissionRequestSignalList +type InstallMissingMediaPluginsPermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method InstallMissingMediaPluginsPermissionRequest::get_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "InstallMissingMediaPluginsPermissionRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitInstallMissingMediaPluginsPermissionRequest", 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_install_missing_media_plugins_permission_request_get_description" webkit_install_missing_media_plugins_permission_request_get_description :: + Ptr InstallMissingMediaPluginsPermissionRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "InstallMissingMediaPluginsPermissionRequest"}) + IO CString + +{- | +Gets the description about the missing plugins provided by the media backend when a media couldn\'t be played. + +/Since: 2.10/ +-} +installMissingMediaPluginsPermissionRequestGetDescription :: + (B.CallStack.HasCallStack, MonadIO m, IsInstallMissingMediaPluginsPermissionRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.InstallMissingMediaPluginsPermissionRequest.InstallMissingMediaPluginsPermissionRequest' -} + -> m T.Text + {- ^ __Returns:__ a string with the description provided by the media backend. -} +installMissingMediaPluginsPermissionRequestGetDescription request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_install_missing_media_plugins_permission_request_get_description request' + checkUnexpectedReturnNULL "installMissingMediaPluginsPermissionRequestGetDescription" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data InstallMissingMediaPluginsPermissionRequestGetDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsInstallMissingMediaPluginsPermissionRequest a) => O.MethodInfo InstallMissingMediaPluginsPermissionRequestGetDescriptionMethodInfo a signature where + overloadedMethod _ = installMissingMediaPluginsPermissionRequestGetDescription + +#endif + + diff --git a/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs-boot b/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/InstallMissingMediaPluginsPermissionRequest.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.InstallMissingMediaPluginsPermissionRequest 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 + +newtype InstallMissingMediaPluginsPermissionRequest = InstallMissingMediaPluginsPermissionRequest (ManagedPtr InstallMissingMediaPluginsPermissionRequest) +instance GObject InstallMissingMediaPluginsPermissionRequest where +class (GObject o, O.IsDescendantOf InstallMissingMediaPluginsPermissionRequest o) => IsInstallMissingMediaPluginsPermissionRequest o +instance (GObject o, O.IsDescendantOf InstallMissingMediaPluginsPermissionRequest o) => IsInstallMissingMediaPluginsPermissionRequest o +instance O.HasParentTypes InstallMissingMediaPluginsPermissionRequest +#if ENABLE_OVERLOADING +data InstallMissingMediaPluginsPermissionRequestGetDescriptionMethodInfo +#endif diff --git a/GI/WebKit2/Objects/NavigationPolicyDecision.hs b/GI/WebKit2/Objects/NavigationPolicyDecision.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/NavigationPolicyDecision.hs @@ -0,0 +1,698 @@ + + +{- | +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.NavigationPolicyDecision + ( + +-- * Exported types + NavigationPolicyDecision(..) , + IsNavigationPolicyDecision , + toNavigationPolicyDecision , + noNavigationPolicyDecision , + + + -- * Methods +-- ** getFrameName #method:getFrameName# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetFrameNameMethodInfo, +#endif + navigationPolicyDecisionGetFrameName , + + +-- ** getModifiers #method:getModifiers# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetModifiersMethodInfo, +#endif + navigationPolicyDecisionGetModifiers , + + +-- ** getMouseButton #method:getMouseButton# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetMouseButtonMethodInfo, +#endif + navigationPolicyDecisionGetMouseButton , + + +-- ** getNavigationAction #method:getNavigationAction# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetNavigationActionMethodInfo, +#endif + navigationPolicyDecisionGetNavigationAction, + + +-- ** getNavigationType #method:getNavigationType# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetNavigationTypeMethodInfo, +#endif + navigationPolicyDecisionGetNavigationType, + + +-- ** getRequest #method:getRequest# + +#if ENABLE_OVERLOADING + NavigationPolicyDecisionGetRequestMethodInfo, +#endif + navigationPolicyDecisionGetRequest , + + + + + -- * Properties +-- ** frameName #attr:frameName# +{- | If this navigation request targets a new frame, this property contains +the name of that frame. For example if the decision was triggered by clicking a +link with a target attribute equal to \"_blank\", this property will contain the +value of that attribute. In all other cases, this value will be 'Nothing'. +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionFrameNamePropertyInfo, +#endif + getNavigationPolicyDecisionFrameName , +#if ENABLE_OVERLOADING + navigationPolicyDecisionFrameName , +#endif + + +-- ** modifiers #attr:modifiers# +{- | If the navigation associated with this policy decision was originally +triggered by a mouse event, this property contains a bitmask of various +'GI.Gdk.Flags.ModifierType' values describing the modifiers used for that click. +If the navigation was not triggered by a mouse event or no modifiers +were active, the value of this property will be zero. +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionModifiersPropertyInfo, +#endif + getNavigationPolicyDecisionModifiers , +#if ENABLE_OVERLOADING + navigationPolicyDecisionModifiers , +#endif + + +-- ** mouseButton #attr:mouseButton# +{- | If the navigation associated with this policy decision was originally +triggered by a mouse event, this property contains non-zero button number +of the button triggering that event. The button numbers match those from GDK. +If the navigation was not triggered by a mouse event, the value of this +property will be 0. +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionMouseButtonPropertyInfo, +#endif + getNavigationPolicyDecisionMouseButton , +#if ENABLE_OVERLOADING + navigationPolicyDecisionMouseButton , +#endif + + +-- ** navigationAction #attr:navigationAction# +{- | The 'GI.WebKit2.Structs.NavigationAction.NavigationAction' that triggered this policy decision. + +/Since: 2.6/ +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionNavigationActionPropertyInfo, +#endif + getNavigationPolicyDecisionNavigationAction, +#if ENABLE_OVERLOADING + navigationPolicyDecisionNavigationAction, +#endif + + +-- ** navigationType #attr:navigationType# +{- | The type of navigation that triggered this policy decision. This is +useful for enacting different policies depending on what type of user +action caused the navigation. +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionNavigationTypePropertyInfo, +#endif + getNavigationPolicyDecisionNavigationType, +#if ENABLE_OVERLOADING + navigationPolicyDecisionNavigationType , +#endif + + +-- ** request #attr:request# +{- | This property contains the 'GI.WebKit2.Objects.URIRequest.URIRequest' associated with this +navigation. +-} +#if ENABLE_OVERLOADING + NavigationPolicyDecisionRequestPropertyInfo, +#endif + getNavigationPolicyDecisionRequest , +#if ENABLE_OVERLOADING + navigationPolicyDecisionRequest , +#endif + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Objects.PolicyDecision as WebKit2.PolicyDecision +import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest +import {-# SOURCE #-} qualified GI.WebKit2.Structs.NavigationAction as WebKit2.NavigationAction + +-- | Memory-managed wrapper type. +newtype NavigationPolicyDecision = NavigationPolicyDecision (ManagedPtr NavigationPolicyDecision) +foreign import ccall "webkit_navigation_policy_decision_get_type" + c_webkit_navigation_policy_decision_get_type :: IO GType + +instance GObject NavigationPolicyDecision where + gobjectType = c_webkit_navigation_policy_decision_get_type + + +-- | Type class for types which can be safely cast to `NavigationPolicyDecision`, for instance with `toNavigationPolicyDecision`. +class (GObject o, O.IsDescendantOf NavigationPolicyDecision o) => IsNavigationPolicyDecision o +instance (GObject o, O.IsDescendantOf NavigationPolicyDecision o) => IsNavigationPolicyDecision o + +instance O.HasParentTypes NavigationPolicyDecision +type instance O.ParentTypes NavigationPolicyDecision = '[WebKit2.PolicyDecision.PolicyDecision, GObject.Object.Object] + +-- | Cast to `NavigationPolicyDecision`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toNavigationPolicyDecision :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m NavigationPolicyDecision +toNavigationPolicyDecision = liftIO . unsafeCastTo NavigationPolicyDecision + +-- | A convenience alias for `Nothing` :: `Maybe` `NavigationPolicyDecision`. +noNavigationPolicyDecision :: Maybe NavigationPolicyDecision +noNavigationPolicyDecision = Nothing + +#if ENABLE_OVERLOADING +type family ResolveNavigationPolicyDecisionMethod (t :: Symbol) (o :: *) :: * where + ResolveNavigationPolicyDecisionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveNavigationPolicyDecisionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveNavigationPolicyDecisionMethod "download" o = WebKit2.PolicyDecision.PolicyDecisionDownloadMethodInfo + ResolveNavigationPolicyDecisionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveNavigationPolicyDecisionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveNavigationPolicyDecisionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveNavigationPolicyDecisionMethod "ignore" o = WebKit2.PolicyDecision.PolicyDecisionIgnoreMethodInfo + ResolveNavigationPolicyDecisionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveNavigationPolicyDecisionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveNavigationPolicyDecisionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveNavigationPolicyDecisionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveNavigationPolicyDecisionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveNavigationPolicyDecisionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveNavigationPolicyDecisionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveNavigationPolicyDecisionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveNavigationPolicyDecisionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveNavigationPolicyDecisionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveNavigationPolicyDecisionMethod "use" o = WebKit2.PolicyDecision.PolicyDecisionUseMethodInfo + ResolveNavigationPolicyDecisionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveNavigationPolicyDecisionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveNavigationPolicyDecisionMethod "getFrameName" o = NavigationPolicyDecisionGetFrameNameMethodInfo + ResolveNavigationPolicyDecisionMethod "getModifiers" o = NavigationPolicyDecisionGetModifiersMethodInfo + ResolveNavigationPolicyDecisionMethod "getMouseButton" o = NavigationPolicyDecisionGetMouseButtonMethodInfo + ResolveNavigationPolicyDecisionMethod "getNavigationAction" o = NavigationPolicyDecisionGetNavigationActionMethodInfo + ResolveNavigationPolicyDecisionMethod "getNavigationType" o = NavigationPolicyDecisionGetNavigationTypeMethodInfo + ResolveNavigationPolicyDecisionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveNavigationPolicyDecisionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveNavigationPolicyDecisionMethod "getRequest" o = NavigationPolicyDecisionGetRequestMethodInfo + ResolveNavigationPolicyDecisionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveNavigationPolicyDecisionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveNavigationPolicyDecisionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNavigationPolicyDecisionMethod t NavigationPolicyDecision, O.MethodInfo info NavigationPolicyDecision p) => OL.IsLabel t (NavigationPolicyDecision -> 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 + +-- VVV Prop "frame-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@frame-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #frameName +@ +-} +getNavigationPolicyDecisionFrameName :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m (Maybe T.Text) +getNavigationPolicyDecisionFrameName obj = liftIO $ B.Properties.getObjectPropertyString obj "frame-name" + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionFrameNamePropertyInfo +instance AttrInfo NavigationPolicyDecisionFrameNamePropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionFrameNamePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NavigationPolicyDecisionFrameNamePropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionFrameNamePropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionFrameNamePropertyInfo = (Maybe T.Text) + type AttrLabel NavigationPolicyDecisionFrameNamePropertyInfo = "frame-name" + type AttrOrigin NavigationPolicyDecisionFrameNamePropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionFrameName + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "modifiers" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@modifiers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #modifiers +@ +-} +getNavigationPolicyDecisionModifiers :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m Word32 +getNavigationPolicyDecisionModifiers obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "modifiers" + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionModifiersPropertyInfo +instance AttrInfo NavigationPolicyDecisionModifiersPropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionModifiersPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint NavigationPolicyDecisionModifiersPropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionModifiersPropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionModifiersPropertyInfo = Word32 + type AttrLabel NavigationPolicyDecisionModifiersPropertyInfo = "modifiers" + type AttrOrigin NavigationPolicyDecisionModifiersPropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionModifiers + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "mouse-button" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@mouse-button@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #mouseButton +@ +-} +getNavigationPolicyDecisionMouseButton :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m Word32 +getNavigationPolicyDecisionMouseButton obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "mouse-button" + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionMouseButtonPropertyInfo +instance AttrInfo NavigationPolicyDecisionMouseButtonPropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionMouseButtonPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint NavigationPolicyDecisionMouseButtonPropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionMouseButtonPropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionMouseButtonPropertyInfo = Word32 + type AttrLabel NavigationPolicyDecisionMouseButtonPropertyInfo = "mouse-button" + type AttrOrigin NavigationPolicyDecisionMouseButtonPropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionMouseButton + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "navigation-action" + -- Type: TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@navigation-action@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #navigationAction +@ +-} +getNavigationPolicyDecisionNavigationAction :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m WebKit2.NavigationAction.NavigationAction +getNavigationPolicyDecisionNavigationAction obj = liftIO $ checkUnexpectedNothing "getNavigationPolicyDecisionNavigationAction" $ B.Properties.getObjectPropertyBoxed obj "navigation-action" WebKit2.NavigationAction.NavigationAction + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionNavigationActionPropertyInfo +instance AttrInfo NavigationPolicyDecisionNavigationActionPropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionNavigationActionPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NavigationPolicyDecisionNavigationActionPropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionNavigationActionPropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionNavigationActionPropertyInfo = WebKit2.NavigationAction.NavigationAction + type AttrLabel NavigationPolicyDecisionNavigationActionPropertyInfo = "navigation-action" + type AttrOrigin NavigationPolicyDecisionNavigationActionPropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionNavigationAction + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "navigation-type" + -- Type: TInterface (Name {namespace = "WebKit2", name = "NavigationType"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@navigation-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #navigationType +@ +-} +getNavigationPolicyDecisionNavigationType :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m WebKit2.Enums.NavigationType +getNavigationPolicyDecisionNavigationType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "navigation-type" + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionNavigationTypePropertyInfo +instance AttrInfo NavigationPolicyDecisionNavigationTypePropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionNavigationTypePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint NavigationPolicyDecisionNavigationTypePropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionNavigationTypePropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionNavigationTypePropertyInfo = WebKit2.Enums.NavigationType + type AttrLabel NavigationPolicyDecisionNavigationTypePropertyInfo = "navigation-type" + type AttrOrigin NavigationPolicyDecisionNavigationTypePropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionNavigationType + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "request" + -- Type: TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@request@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' navigationPolicyDecision #request +@ +-} +getNavigationPolicyDecisionRequest :: (MonadIO m, IsNavigationPolicyDecision o) => o -> m WebKit2.URIRequest.URIRequest +getNavigationPolicyDecisionRequest obj = liftIO $ checkUnexpectedNothing "getNavigationPolicyDecisionRequest" $ B.Properties.getObjectPropertyObject obj "request" WebKit2.URIRequest.URIRequest + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionRequestPropertyInfo +instance AttrInfo NavigationPolicyDecisionRequestPropertyInfo where + type AttrAllowedOps NavigationPolicyDecisionRequestPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NavigationPolicyDecisionRequestPropertyInfo = (~) () + type AttrBaseTypeConstraint NavigationPolicyDecisionRequestPropertyInfo = IsNavigationPolicyDecision + type AttrGetType NavigationPolicyDecisionRequestPropertyInfo = WebKit2.URIRequest.URIRequest + type AttrLabel NavigationPolicyDecisionRequestPropertyInfo = "request" + type AttrOrigin NavigationPolicyDecisionRequestPropertyInfo = NavigationPolicyDecision + attrGet _ = getNavigationPolicyDecisionRequest + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList NavigationPolicyDecision +type instance O.AttributeList NavigationPolicyDecision = NavigationPolicyDecisionAttributeList +type NavigationPolicyDecisionAttributeList = ('[ '("frameName", NavigationPolicyDecisionFrameNamePropertyInfo), '("modifiers", NavigationPolicyDecisionModifiersPropertyInfo), '("mouseButton", NavigationPolicyDecisionMouseButtonPropertyInfo), '("navigationAction", NavigationPolicyDecisionNavigationActionPropertyInfo), '("navigationType", NavigationPolicyDecisionNavigationTypePropertyInfo), '("request", NavigationPolicyDecisionRequestPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +navigationPolicyDecisionFrameName :: AttrLabelProxy "frameName" +navigationPolicyDecisionFrameName = AttrLabelProxy + +navigationPolicyDecisionModifiers :: AttrLabelProxy "modifiers" +navigationPolicyDecisionModifiers = AttrLabelProxy + +navigationPolicyDecisionMouseButton :: AttrLabelProxy "mouseButton" +navigationPolicyDecisionMouseButton = AttrLabelProxy + +navigationPolicyDecisionNavigationAction :: AttrLabelProxy "navigationAction" +navigationPolicyDecisionNavigationAction = AttrLabelProxy + +navigationPolicyDecisionNavigationType :: AttrLabelProxy "navigationType" +navigationPolicyDecisionNavigationType = AttrLabelProxy + +navigationPolicyDecisionRequest :: AttrLabelProxy "request" +navigationPolicyDecisionRequest = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList NavigationPolicyDecision = NavigationPolicyDecisionSignalList +type NavigationPolicyDecisionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method NavigationPolicyDecision::get_frame_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", 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_navigation_policy_decision_get_frame_name" webkit_navigation_policy_decision_get_frame_name :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/frame-name/@ property. +-} +navigationPolicyDecisionGetFrameName :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ The name of the new frame this navigation action targets or 'Nothing' -} +navigationPolicyDecisionGetFrameName decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_frame_name decision' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr decision + return maybeResult + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetFrameNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetFrameNameMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetFrameName + +#endif + +-- method NavigationPolicyDecision::get_modifiers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_policy_decision_get_modifiers" webkit_navigation_policy_decision_get_modifiers :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO Word32 + +{-# DEPRECATED navigationPolicyDecisionGetModifiers ["(Since version 2.6)","Use 'GI.WebKit2.Objects.NavigationPolicyDecision.navigationPolicyDecisionGetNavigationAction' instead."] #-} +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/modifiers/@ property. +-} +navigationPolicyDecisionGetModifiers :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m Word32 + {- ^ __Returns:__ The modifiers active if this decision was triggered by a mouse event -} +navigationPolicyDecisionGetModifiers decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_modifiers decision' + touchManagedPtr decision + return result + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetModifiersMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetModifiersMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetModifiers + +#endif + +-- method NavigationPolicyDecision::get_mouse_button +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_policy_decision_get_mouse_button" webkit_navigation_policy_decision_get_mouse_button :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO Word32 + +{-# DEPRECATED navigationPolicyDecisionGetMouseButton ["(Since version 2.6)","Use 'GI.WebKit2.Objects.NavigationPolicyDecision.navigationPolicyDecisionGetNavigationAction' instead."] #-} +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/mouse-button/@ property. +-} +navigationPolicyDecisionGetMouseButton :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m Word32 + {- ^ __Returns:__ The mouse button used if this decision was triggered by a mouse event or 0 otherwise -} +navigationPolicyDecisionGetMouseButton decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_mouse_button decision' + touchManagedPtr decision + return result + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetMouseButtonMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetMouseButtonMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetMouseButton + +#endif + +-- method NavigationPolicyDecision::get_navigation_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NavigationAction"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_policy_decision_get_navigation_action" webkit_navigation_policy_decision_get_navigation_action :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO (Ptr WebKit2.NavigationAction.NavigationAction) + +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/navigation-action/@ property. + +/Since: 2.6/ +-} +navigationPolicyDecisionGetNavigationAction :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m WebKit2.NavigationAction.NavigationAction + {- ^ __Returns:__ The 'GI.WebKit2.Structs.NavigationAction.NavigationAction' triggering this policy decision. -} +navigationPolicyDecisionGetNavigationAction decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_navigation_action decision' + checkUnexpectedReturnNULL "navigationPolicyDecisionGetNavigationAction" result + result' <- (newBoxed WebKit2.NavigationAction.NavigationAction) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetNavigationActionMethodInfo +instance (signature ~ (m WebKit2.NavigationAction.NavigationAction), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetNavigationActionMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetNavigationAction + +#endif + +-- method NavigationPolicyDecision::get_navigation_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NavigationType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_policy_decision_get_navigation_type" webkit_navigation_policy_decision_get_navigation_type :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO CUInt + +{-# DEPRECATED navigationPolicyDecisionGetNavigationType ["(Since version 2.6)","Use 'GI.WebKit2.Objects.NavigationPolicyDecision.navigationPolicyDecisionGetNavigationAction' instead."] #-} +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/navigation-type/@ property. +-} +navigationPolicyDecisionGetNavigationType :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m WebKit2.Enums.NavigationType + {- ^ __Returns:__ The type of navigation triggering this policy decision. -} +navigationPolicyDecisionGetNavigationType decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_navigation_type decision' + let result' = (toEnum . fromIntegral) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetNavigationTypeMethodInfo +instance (signature ~ (m WebKit2.Enums.NavigationType), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetNavigationTypeMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetNavigationType + +#endif + +-- method NavigationPolicyDecision::get_request +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIRequest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_policy_decision_get_request" webkit_navigation_policy_decision_get_request :: + Ptr NavigationPolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "NavigationPolicyDecision"}) + IO (Ptr WebKit2.URIRequest.URIRequest) + +{-# DEPRECATED navigationPolicyDecisionGetRequest ["(Since version 2.6)","Use 'GI.WebKit2.Objects.NavigationPolicyDecision.navigationPolicyDecisionGetNavigationAction' instead."] #-} +{- | +Gets the value of the 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision':@/request/@ property. +-} +navigationPolicyDecisionGetRequest :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigationPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' -} + -> m WebKit2.URIRequest.URIRequest + {- ^ __Returns:__ The URI request that is associated with this navigation -} +navigationPolicyDecisionGetRequest decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_navigation_policy_decision_get_request decision' + checkUnexpectedReturnNULL "navigationPolicyDecisionGetRequest" result + result' <- (newObject WebKit2.URIRequest.URIRequest) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetRequestMethodInfo +instance (signature ~ (m WebKit2.URIRequest.URIRequest), MonadIO m, IsNavigationPolicyDecision a) => O.MethodInfo NavigationPolicyDecisionGetRequestMethodInfo a signature where + overloadedMethod _ = navigationPolicyDecisionGetRequest + +#endif + + diff --git a/GI/WebKit2/Objects/NavigationPolicyDecision.hs-boot b/GI/WebKit2/Objects/NavigationPolicyDecision.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/NavigationPolicyDecision.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.NavigationPolicyDecision 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 + +newtype NavigationPolicyDecision = NavigationPolicyDecision (ManagedPtr NavigationPolicyDecision) +instance GObject NavigationPolicyDecision where +class (GObject o, O.IsDescendantOf NavigationPolicyDecision o) => IsNavigationPolicyDecision o +instance (GObject o, O.IsDescendantOf NavigationPolicyDecision o) => IsNavigationPolicyDecision o +instance O.HasParentTypes NavigationPolicyDecision +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionFrameNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionModifiersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionMouseButtonPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionNavigationActionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionNavigationTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionRequestPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetFrameNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetModifiersMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetMouseButtonMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetNavigationActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetNavigationTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationPolicyDecisionGetRequestMethodInfo +#endif diff --git a/GI/WebKit2/Objects/Notification.hs b/GI/WebKit2/Objects/Notification.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Notification.hs @@ -0,0 +1,781 @@ + + +{- | +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.Notification + ( + +-- * Exported types + Notification(..) , + IsNotification , + toNotification , + noNotification , + + + -- * Methods +-- ** clicked #method:clicked# + +#if ENABLE_OVERLOADING + NotificationClickedMethodInfo , +#endif + notificationClicked , + + +-- ** close #method:close# + +#if ENABLE_OVERLOADING + NotificationCloseMethodInfo , +#endif + notificationClose , + + +-- ** getBody #method:getBody# + +#if ENABLE_OVERLOADING + NotificationGetBodyMethodInfo , +#endif + notificationGetBody , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + NotificationGetIdMethodInfo , +#endif + notificationGetId , + + +-- ** getTag #method:getTag# + +#if ENABLE_OVERLOADING + NotificationGetTagMethodInfo , +#endif + notificationGetTag , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + NotificationGetTitleMethodInfo , +#endif + notificationGetTitle , + + + + + -- * Properties +-- ** body #attr:body# +{- | The body for the notification. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + NotificationBodyPropertyInfo , +#endif + getNotificationBody , +#if ENABLE_OVERLOADING + notificationBody , +#endif + + +-- ** id #attr:id# +{- | The unique id for the notification. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + NotificationIdPropertyInfo , +#endif + getNotificationId , +#if ENABLE_OVERLOADING + notificationId , +#endif + + +-- ** tag #attr:tag# +{- | The tag identifier for the notification. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + NotificationTagPropertyInfo , +#endif + getNotificationTag , +#if ENABLE_OVERLOADING + notificationTag , +#endif + + +-- ** title #attr:title# +{- | The title for the notification. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + NotificationTitlePropertyInfo , +#endif + getNotificationTitle , +#if ENABLE_OVERLOADING + notificationTitle , +#endif + + + + + -- * Signals +-- ** clicked #signal:clicked# + + C_NotificationClickedCallback , + NotificationClickedCallback , +#if ENABLE_OVERLOADING + NotificationClickedSignalInfo , +#endif + afterNotificationClicked , + genClosure_NotificationClicked , + mk_NotificationClickedCallback , + noNotificationClickedCallback , + onNotificationClicked , + wrap_NotificationClickedCallback , + + +-- ** closed #signal:closed# + + C_NotificationClosedCallback , + NotificationClosedCallback , +#if ENABLE_OVERLOADING + NotificationClosedSignalInfo , +#endif + afterNotificationClosed , + genClosure_NotificationClosed , + mk_NotificationClosedCallback , + noNotificationClosedCallback , + onNotificationClosed , + wrap_NotificationClosedCallback , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype Notification = Notification (ManagedPtr Notification) +foreign import ccall "webkit_notification_get_type" + c_webkit_notification_get_type :: IO GType + +instance GObject Notification where + gobjectType = c_webkit_notification_get_type + + +-- | Type class for types which can be safely cast to `Notification`, for instance with `toNotification`. +class (GObject o, O.IsDescendantOf Notification o) => IsNotification o +instance (GObject o, O.IsDescendantOf Notification o) => IsNotification o + +instance O.HasParentTypes Notification +type instance O.ParentTypes Notification = '[GObject.Object.Object] + +-- | Cast to `Notification`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toNotification :: (MonadIO m, IsNotification o) => o -> m Notification +toNotification = liftIO . unsafeCastTo Notification + +-- | A convenience alias for `Nothing` :: `Maybe` `Notification`. +noNotification :: Maybe Notification +noNotification = Nothing + +#if ENABLE_OVERLOADING +type family ResolveNotificationMethod (t :: Symbol) (o :: *) :: * where + ResolveNotificationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveNotificationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveNotificationMethod "clicked" o = NotificationClickedMethodInfo + ResolveNotificationMethod "close" o = NotificationCloseMethodInfo + ResolveNotificationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveNotificationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveNotificationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveNotificationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveNotificationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveNotificationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveNotificationMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveNotificationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveNotificationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveNotificationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveNotificationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveNotificationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveNotificationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveNotificationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveNotificationMethod "getBody" o = NotificationGetBodyMethodInfo + ResolveNotificationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveNotificationMethod "getId" o = NotificationGetIdMethodInfo + ResolveNotificationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveNotificationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveNotificationMethod "getTag" o = NotificationGetTagMethodInfo + ResolveNotificationMethod "getTitle" o = NotificationGetTitleMethodInfo + ResolveNotificationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveNotificationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveNotificationMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNotificationMethod t Notification, O.MethodInfo info Notification p) => OL.IsLabel t (Notification -> 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 Notification::clicked +{- | +Emitted when a notification has been clicked. See 'GI.WebKit2.Objects.Notification.notificationClicked'. + +/Since: 2.12/ +-} +type NotificationClickedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `NotificationClickedCallback`@. +noNotificationClickedCallback :: Maybe NotificationClickedCallback +noNotificationClickedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_NotificationClickedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_NotificationClickedCallback`. +foreign import ccall "wrapper" + mk_NotificationClickedCallback :: C_NotificationClickedCallback -> IO (FunPtr C_NotificationClickedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_NotificationClicked :: MonadIO m => NotificationClickedCallback -> m (GClosure C_NotificationClickedCallback) +genClosure_NotificationClicked cb = liftIO $ do + let cb' = wrap_NotificationClickedCallback cb + mk_NotificationClickedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `NotificationClickedCallback` into a `C_NotificationClickedCallback`. +wrap_NotificationClickedCallback :: + NotificationClickedCallback -> + C_NotificationClickedCallback +wrap_NotificationClickedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@clicked@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' notification #clicked callback +@ +-} +onNotificationClicked :: (IsNotification a, MonadIO m) => a -> NotificationClickedCallback -> m SignalHandlerId +onNotificationClicked obj cb = liftIO $ do + let cb' = wrap_NotificationClickedCallback cb + cb'' <- mk_NotificationClickedCallback cb' + connectSignalFunPtr obj "clicked" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@clicked@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' notification #clicked callback +@ +-} +afterNotificationClicked :: (IsNotification a, MonadIO m) => a -> NotificationClickedCallback -> m SignalHandlerId +afterNotificationClicked obj cb = liftIO $ do + let cb' = wrap_NotificationClickedCallback cb + cb'' <- mk_NotificationClickedCallback cb' + connectSignalFunPtr obj "clicked" cb'' SignalConnectAfter + + +-- signal Notification::closed +{- | +Emitted when a notification has been withdrawn. + +The default handler will close the notification using libnotify, if built with +support for it. + +/Since: 2.8/ +-} +type NotificationClosedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `NotificationClosedCallback`@. +noNotificationClosedCallback :: Maybe NotificationClosedCallback +noNotificationClosedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_NotificationClosedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_NotificationClosedCallback`. +foreign import ccall "wrapper" + mk_NotificationClosedCallback :: C_NotificationClosedCallback -> IO (FunPtr C_NotificationClosedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_NotificationClosed :: MonadIO m => NotificationClosedCallback -> m (GClosure C_NotificationClosedCallback) +genClosure_NotificationClosed cb = liftIO $ do + let cb' = wrap_NotificationClosedCallback cb + mk_NotificationClosedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `NotificationClosedCallback` into a `C_NotificationClosedCallback`. +wrap_NotificationClosedCallback :: + NotificationClosedCallback -> + C_NotificationClosedCallback +wrap_NotificationClosedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@closed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' notification #closed callback +@ +-} +onNotificationClosed :: (IsNotification a, MonadIO m) => a -> NotificationClosedCallback -> m SignalHandlerId +onNotificationClosed obj cb = liftIO $ do + let cb' = wrap_NotificationClosedCallback cb + cb'' <- mk_NotificationClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@closed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' notification #closed callback +@ +-} +afterNotificationClosed :: (IsNotification a, MonadIO m) => a -> NotificationClosedCallback -> m SignalHandlerId +afterNotificationClosed obj cb = liftIO $ do + let cb' = wrap_NotificationClosedCallback cb + cb'' <- mk_NotificationClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' SignalConnectAfter + + +-- VVV Prop "body" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@body@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' notification #body +@ +-} +getNotificationBody :: (MonadIO m, IsNotification o) => o -> m T.Text +getNotificationBody obj = liftIO $ checkUnexpectedNothing "getNotificationBody" $ B.Properties.getObjectPropertyString obj "body" + +#if ENABLE_OVERLOADING +data NotificationBodyPropertyInfo +instance AttrInfo NotificationBodyPropertyInfo where + type AttrAllowedOps NotificationBodyPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NotificationBodyPropertyInfo = (~) () + type AttrBaseTypeConstraint NotificationBodyPropertyInfo = IsNotification + type AttrGetType NotificationBodyPropertyInfo = T.Text + type AttrLabel NotificationBodyPropertyInfo = "body" + type AttrOrigin NotificationBodyPropertyInfo = Notification + attrGet _ = getNotificationBody + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "id" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' notification #id +@ +-} +getNotificationId :: (MonadIO m, IsNotification o) => o -> m Word64 +getNotificationId obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "id" + +#if ENABLE_OVERLOADING +data NotificationIdPropertyInfo +instance AttrInfo NotificationIdPropertyInfo where + type AttrAllowedOps NotificationIdPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint NotificationIdPropertyInfo = (~) () + type AttrBaseTypeConstraint NotificationIdPropertyInfo = IsNotification + type AttrGetType NotificationIdPropertyInfo = Word64 + type AttrLabel NotificationIdPropertyInfo = "id" + type AttrOrigin NotificationIdPropertyInfo = Notification + attrGet _ = getNotificationId + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "tag" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@tag@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' notification #tag +@ +-} +getNotificationTag :: (MonadIO m, IsNotification o) => o -> m (Maybe T.Text) +getNotificationTag obj = liftIO $ B.Properties.getObjectPropertyString obj "tag" + +#if ENABLE_OVERLOADING +data NotificationTagPropertyInfo +instance AttrInfo NotificationTagPropertyInfo where + type AttrAllowedOps NotificationTagPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NotificationTagPropertyInfo = (~) () + type AttrBaseTypeConstraint NotificationTagPropertyInfo = IsNotification + type AttrGetType NotificationTagPropertyInfo = (Maybe T.Text) + type AttrLabel NotificationTagPropertyInfo = "tag" + type AttrOrigin NotificationTagPropertyInfo = Notification + attrGet _ = getNotificationTag + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "title" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' notification #title +@ +-} +getNotificationTitle :: (MonadIO m, IsNotification o) => o -> m T.Text +getNotificationTitle obj = liftIO $ checkUnexpectedNothing "getNotificationTitle" $ B.Properties.getObjectPropertyString obj "title" + +#if ENABLE_OVERLOADING +data NotificationTitlePropertyInfo +instance AttrInfo NotificationTitlePropertyInfo where + type AttrAllowedOps NotificationTitlePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint NotificationTitlePropertyInfo = (~) () + type AttrBaseTypeConstraint NotificationTitlePropertyInfo = IsNotification + type AttrGetType NotificationTitlePropertyInfo = T.Text + type AttrLabel NotificationTitlePropertyInfo = "title" + type AttrOrigin NotificationTitlePropertyInfo = Notification + attrGet _ = getNotificationTitle + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Notification +type instance O.AttributeList Notification = NotificationAttributeList +type NotificationAttributeList = ('[ '("body", NotificationBodyPropertyInfo), '("id", NotificationIdPropertyInfo), '("tag", NotificationTagPropertyInfo), '("title", NotificationTitlePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +notificationBody :: AttrLabelProxy "body" +notificationBody = AttrLabelProxy + +notificationId :: AttrLabelProxy "id" +notificationId = AttrLabelProxy + +notificationTag :: AttrLabelProxy "tag" +notificationTag = AttrLabelProxy + +notificationTitle :: AttrLabelProxy "title" +notificationTitle = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data NotificationClickedSignalInfo +instance SignalInfo NotificationClickedSignalInfo where + type HaskellCallbackType NotificationClickedSignalInfo = NotificationClickedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_NotificationClickedCallback cb + cb'' <- mk_NotificationClickedCallback cb' + connectSignalFunPtr obj "clicked" cb'' connectMode + +data NotificationClosedSignalInfo +instance SignalInfo NotificationClosedSignalInfo where + type HaskellCallbackType NotificationClosedSignalInfo = NotificationClosedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_NotificationClosedCallback cb + cb'' <- mk_NotificationClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' connectMode + +type instance O.SignalList Notification = NotificationSignalList +type NotificationSignalList = ('[ '("clicked", NotificationClickedSignalInfo), '("closed", NotificationClosedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Notification::clicked +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_notification_clicked" webkit_notification_clicked :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO () + +{- | +Tells WebKit the notification has been clicked. This will emit the +'GI.WebKit2.Objects.Notification.Notification'::@/clicked/@ signal. + +/Since: 2.12/ +-} +notificationClicked :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m () +notificationClicked notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + webkit_notification_clicked notification' + touchManagedPtr notification + return () + +#if ENABLE_OVERLOADING +data NotificationClickedMethodInfo +instance (signature ~ (m ()), MonadIO m, IsNotification a) => O.MethodInfo NotificationClickedMethodInfo a signature where + overloadedMethod _ = notificationClicked + +#endif + +-- method Notification::close +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_notification_close" webkit_notification_close :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO () + +{- | +Closes the notification. + +/Since: 2.8/ +-} +notificationClose :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m () +notificationClose notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + webkit_notification_close notification' + touchManagedPtr notification + return () + +#if ENABLE_OVERLOADING +data NotificationCloseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsNotification a) => O.MethodInfo NotificationCloseMethodInfo a signature where + overloadedMethod _ = notificationClose + +#endif + +-- method Notification::get_body +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", 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_notification_get_body" webkit_notification_get_body :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO CString + +{- | +Obtains the body for the notification. + +/Since: 2.8/ +-} +notificationGetBody :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m T.Text + {- ^ __Returns:__ the body for the notification -} +notificationGetBody notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + result <- webkit_notification_get_body notification' + checkUnexpectedReturnNULL "notificationGetBody" result + result' <- cstringToText result + touchManagedPtr notification + return result' + +#if ENABLE_OVERLOADING +data NotificationGetBodyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsNotification a) => O.MethodInfo NotificationGetBodyMethodInfo a signature where + overloadedMethod _ = notificationGetBody + +#endif + +-- method Notification::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_notification_get_id" webkit_notification_get_id :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO Word64 + +{- | +Obtains the unique id for the notification. + +/Since: 2.8/ +-} +notificationGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m Word64 + {- ^ __Returns:__ the unique id for the notification -} +notificationGetId notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + result <- webkit_notification_get_id notification' + touchManagedPtr notification + return result + +#if ENABLE_OVERLOADING +data NotificationGetIdMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsNotification a) => O.MethodInfo NotificationGetIdMethodInfo a signature where + overloadedMethod _ = notificationGetId + +#endif + +-- method Notification::get_tag +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", 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_notification_get_tag" webkit_notification_get_tag :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO CString + +{- | +Obtains the tag identifier for the notification. + +/Since: 2.16/ +-} +notificationGetTag :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the tag for the notification -} +notificationGetTag notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + result <- webkit_notification_get_tag notification' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr notification + return maybeResult + +#if ENABLE_OVERLOADING +data NotificationGetTagMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsNotification a) => O.MethodInfo NotificationGetTagMethodInfo a signature where + overloadedMethod _ = notificationGetTag + +#endif + +-- method Notification::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "notification", argType = TInterface (Name {namespace = "WebKit2", name = "Notification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNotification", 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_notification_get_title" webkit_notification_get_title :: + Ptr Notification -> -- notification : TInterface (Name {namespace = "WebKit2", name = "Notification"}) + IO CString + +{- | +Obtains the title for the notification. + +/Since: 2.8/ +-} +notificationGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsNotification a) => + a + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> m T.Text + {- ^ __Returns:__ the title for the notification -} +notificationGetTitle notification = liftIO $ do + notification' <- unsafeManagedPtrCastPtr notification + result <- webkit_notification_get_title notification' + checkUnexpectedReturnNULL "notificationGetTitle" result + result' <- cstringToText result + touchManagedPtr notification + return result' + +#if ENABLE_OVERLOADING +data NotificationGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsNotification a) => O.MethodInfo NotificationGetTitleMethodInfo a signature where + overloadedMethod _ = notificationGetTitle + +#endif + + diff --git a/GI/WebKit2/Objects/Notification.hs-boot b/GI/WebKit2/Objects/Notification.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Notification.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.Notification 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 + +newtype Notification = Notification (ManagedPtr Notification) +instance GObject Notification where +class (GObject o, O.IsDescendantOf Notification o) => IsNotification o +instance (GObject o, O.IsDescendantOf Notification o) => IsNotification o +instance O.HasParentTypes Notification +#if ENABLE_OVERLOADING +data NotificationBodyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NotificationIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NotificationTagPropertyInfo +#endif +#if ENABLE_OVERLOADING +data NotificationTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data NotificationClickedSignalInfo +#endif +#if ENABLE_OVERLOADING +data NotificationClosedSignalInfo +#endif +#if ENABLE_OVERLOADING +data NotificationClickedMethodInfo +#endif +#if ENABLE_OVERLOADING +data NotificationCloseMethodInfo +#endif +#if ENABLE_OVERLOADING +data NotificationGetBodyMethodInfo +#endif +#if ENABLE_OVERLOADING +data NotificationGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data NotificationGetTagMethodInfo +#endif +#if ENABLE_OVERLOADING +data NotificationGetTitleMethodInfo +#endif diff --git a/GI/WebKit2/Objects/NotificationPermissionRequest.hs b/GI/WebKit2/Objects/NotificationPermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/NotificationPermissionRequest.hs @@ -0,0 +1,124 @@ + + +{- | +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.NotificationPermissionRequest + ( + +-- * Exported types + NotificationPermissionRequest(..) , + IsNotificationPermissionRequest , + toNotificationPermissionRequest , + noNotificationPermissionRequest , + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest + +-- | Memory-managed wrapper type. +newtype NotificationPermissionRequest = NotificationPermissionRequest (ManagedPtr NotificationPermissionRequest) +foreign import ccall "webkit_notification_permission_request_get_type" + c_webkit_notification_permission_request_get_type :: IO GType + +instance GObject NotificationPermissionRequest where + gobjectType = c_webkit_notification_permission_request_get_type + + +-- | Type class for types which can be safely cast to `NotificationPermissionRequest`, for instance with `toNotificationPermissionRequest`. +class (GObject o, O.IsDescendantOf NotificationPermissionRequest o) => IsNotificationPermissionRequest o +instance (GObject o, O.IsDescendantOf NotificationPermissionRequest o) => IsNotificationPermissionRequest o + +instance O.HasParentTypes NotificationPermissionRequest +type instance O.ParentTypes NotificationPermissionRequest = '[GObject.Object.Object, WebKit2.PermissionRequest.PermissionRequest] + +-- | Cast to `NotificationPermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toNotificationPermissionRequest :: (MonadIO m, IsNotificationPermissionRequest o) => o -> m NotificationPermissionRequest +toNotificationPermissionRequest = liftIO . unsafeCastTo NotificationPermissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `NotificationPermissionRequest`. +noNotificationPermissionRequest :: Maybe NotificationPermissionRequest +noNotificationPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveNotificationPermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveNotificationPermissionRequestMethod "allow" o = WebKit2.PermissionRequest.PermissionRequestAllowMethodInfo + ResolveNotificationPermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveNotificationPermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveNotificationPermissionRequestMethod "deny" o = WebKit2.PermissionRequest.PermissionRequestDenyMethodInfo + ResolveNotificationPermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveNotificationPermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveNotificationPermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveNotificationPermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveNotificationPermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveNotificationPermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveNotificationPermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveNotificationPermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveNotificationPermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveNotificationPermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveNotificationPermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveNotificationPermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveNotificationPermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveNotificationPermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveNotificationPermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveNotificationPermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveNotificationPermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveNotificationPermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveNotificationPermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveNotificationPermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNotificationPermissionRequestMethod t NotificationPermissionRequest, O.MethodInfo info NotificationPermissionRequest p) => OL.IsLabel t (NotificationPermissionRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList NotificationPermissionRequest +type instance O.AttributeList NotificationPermissionRequest = NotificationPermissionRequestAttributeList +type NotificationPermissionRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList NotificationPermissionRequest = NotificationPermissionRequestSignalList +type NotificationPermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/WebKit2/Objects/NotificationPermissionRequest.hs-boot b/GI/WebKit2/Objects/NotificationPermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/NotificationPermissionRequest.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.NotificationPermissionRequest 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 + +newtype NotificationPermissionRequest = NotificationPermissionRequest (ManagedPtr NotificationPermissionRequest) +instance GObject NotificationPermissionRequest where +class (GObject o, O.IsDescendantOf NotificationPermissionRequest o) => IsNotificationPermissionRequest o +instance (GObject o, O.IsDescendantOf NotificationPermissionRequest o) => IsNotificationPermissionRequest o +instance O.HasParentTypes NotificationPermissionRequest diff --git a/GI/WebKit2/Objects/OptionMenu.hs b/GI/WebKit2/Objects/OptionMenu.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/OptionMenu.hs @@ -0,0 +1,464 @@ + + +{- | +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.OptionMenu + ( + +-- * Exported types + OptionMenu(..) , + IsOptionMenu , + toOptionMenu , + noOptionMenu , + + + -- * Methods +-- ** activateItem #method:activateItem# + +#if ENABLE_OVERLOADING + OptionMenuActivateItemMethodInfo , +#endif + optionMenuActivateItem , + + +-- ** close #method:close# + +#if ENABLE_OVERLOADING + OptionMenuCloseMethodInfo , +#endif + optionMenuClose , + + +-- ** getItem #method:getItem# + +#if ENABLE_OVERLOADING + OptionMenuGetItemMethodInfo , +#endif + optionMenuGetItem , + + +-- ** getNItems #method:getNItems# + +#if ENABLE_OVERLOADING + OptionMenuGetNItemsMethodInfo , +#endif + optionMenuGetNItems , + + +-- ** selectItem #method:selectItem# + +#if ENABLE_OVERLOADING + OptionMenuSelectItemMethodInfo , +#endif + optionMenuSelectItem , + + + + + -- * Signals +-- ** close #signal:close# + + C_OptionMenuCloseCallback , + OptionMenuCloseCallback , +#if ENABLE_OVERLOADING + OptionMenuCloseSignalInfo , +#endif + afterOptionMenuClose , + genClosure_OptionMenuClose , + mk_OptionMenuCloseCallback , + noOptionMenuCloseCallback , + onOptionMenuClose , + wrap_OptionMenuCloseCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Structs.OptionMenuItem as WebKit2.OptionMenuItem + +-- | Memory-managed wrapper type. +newtype OptionMenu = OptionMenu (ManagedPtr OptionMenu) +foreign import ccall "webkit_option_menu_get_type" + c_webkit_option_menu_get_type :: IO GType + +instance GObject OptionMenu where + gobjectType = c_webkit_option_menu_get_type + + +-- | Type class for types which can be safely cast to `OptionMenu`, for instance with `toOptionMenu`. +class (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o +instance (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o + +instance O.HasParentTypes OptionMenu +type instance O.ParentTypes OptionMenu = '[GObject.Object.Object] + +-- | Cast to `OptionMenu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toOptionMenu :: (MonadIO m, IsOptionMenu o) => o -> m OptionMenu +toOptionMenu = liftIO . unsafeCastTo OptionMenu + +-- | A convenience alias for `Nothing` :: `Maybe` `OptionMenu`. +noOptionMenu :: Maybe OptionMenu +noOptionMenu = Nothing + +#if ENABLE_OVERLOADING +type family ResolveOptionMenuMethod (t :: Symbol) (o :: *) :: * where + ResolveOptionMenuMethod "activateItem" o = OptionMenuActivateItemMethodInfo + ResolveOptionMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveOptionMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveOptionMenuMethod "close" o = OptionMenuCloseMethodInfo + ResolveOptionMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveOptionMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveOptionMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveOptionMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveOptionMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveOptionMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveOptionMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveOptionMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveOptionMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveOptionMenuMethod "selectItem" o = OptionMenuSelectItemMethodInfo + ResolveOptionMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveOptionMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveOptionMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveOptionMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveOptionMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveOptionMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveOptionMenuMethod "getItem" o = OptionMenuGetItemMethodInfo + ResolveOptionMenuMethod "getNItems" o = OptionMenuGetNItemsMethodInfo + ResolveOptionMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveOptionMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveOptionMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveOptionMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveOptionMenuMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveOptionMenuMethod t OptionMenu, O.MethodInfo info OptionMenu p) => OL.IsLabel t (OptionMenu -> 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 OptionMenu::close +{- | +Emitted when closing a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' is requested. This can happen +when the user explicitly calls 'GI.WebKit2.Objects.OptionMenu.optionMenuClose' or when the +element is detached from the current page. + +/Since: 2.18/ +-} +type OptionMenuCloseCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionMenuCloseCallback`@. +noOptionMenuCloseCallback :: Maybe OptionMenuCloseCallback +noOptionMenuCloseCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_OptionMenuCloseCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_OptionMenuCloseCallback`. +foreign import ccall "wrapper" + mk_OptionMenuCloseCallback :: C_OptionMenuCloseCallback -> IO (FunPtr C_OptionMenuCloseCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_OptionMenuClose :: MonadIO m => OptionMenuCloseCallback -> m (GClosure C_OptionMenuCloseCallback) +genClosure_OptionMenuClose cb = liftIO $ do + let cb' = wrap_OptionMenuCloseCallback cb + mk_OptionMenuCloseCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `OptionMenuCloseCallback` into a `C_OptionMenuCloseCallback`. +wrap_OptionMenuCloseCallback :: + OptionMenuCloseCallback -> + C_OptionMenuCloseCallback +wrap_OptionMenuCloseCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@close@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' optionMenu #close callback +@ +-} +onOptionMenuClose :: (IsOptionMenu a, MonadIO m) => a -> OptionMenuCloseCallback -> m SignalHandlerId +onOptionMenuClose obj cb = liftIO $ do + let cb' = wrap_OptionMenuCloseCallback cb + cb'' <- mk_OptionMenuCloseCallback cb' + connectSignalFunPtr obj "close" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@close@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' optionMenu #close callback +@ +-} +afterOptionMenuClose :: (IsOptionMenu a, MonadIO m) => a -> OptionMenuCloseCallback -> m SignalHandlerId +afterOptionMenuClose obj cb = liftIO $ do + let cb' = wrap_OptionMenuCloseCallback cb + cb'' <- mk_OptionMenuCloseCallback cb' + connectSignalFunPtr obj "close" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList OptionMenu +type instance O.AttributeList OptionMenu = OptionMenuAttributeList +type OptionMenuAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data OptionMenuCloseSignalInfo +instance SignalInfo OptionMenuCloseSignalInfo where + type HaskellCallbackType OptionMenuCloseSignalInfo = OptionMenuCloseCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_OptionMenuCloseCallback cb + cb'' <- mk_OptionMenuCloseCallback cb' + connectSignalFunPtr obj "close" cb'' connectMode + +type instance O.SignalList OptionMenu = OptionMenuSignalList +type OptionMenuSignalList = ('[ '("close", OptionMenuCloseSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method OptionMenu::activate_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_activate_item" webkit_option_menu_activate_item :: + Ptr OptionMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}) + Word32 -> -- index : TBasicType TUInt + IO () + +{- | +Activates the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/. Activating an item changes the value +of the element making the item the active one. You are expected to close the menu with +'GI.WebKit2.Objects.OptionMenu.optionMenuClose' after activating an item, calling this function again will have no +effect. + +/Since: 2.18/ +-} +optionMenuActivateItem :: + (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> Word32 + {- ^ /@index@/: the index of the item -} + -> m () +optionMenuActivateItem menu index = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + webkit_option_menu_activate_item menu' index + touchManagedPtr menu + return () + +#if ENABLE_OVERLOADING +data OptionMenuActivateItemMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsOptionMenu a) => O.MethodInfo OptionMenuActivateItemMethodInfo a signature where + overloadedMethod _ = optionMenuActivateItem + +#endif + +-- method OptionMenu::close +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_close" webkit_option_menu_close :: + Ptr OptionMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}) + IO () + +{- | +Request to close a 'GI.WebKit2.Objects.OptionMenu.OptionMenu'. This emits WebKitOptionMenu::close signal. +This function should always be called to notify WebKit that the associated +menu has been closed. If the menu is closed and neither 'GI.WebKit2.Objects.OptionMenu.optionMenuSelectItem' +nor 'GI.WebKit2.Objects.OptionMenu.optionMenuActivateItem' have been called, the element value remains +unchanged. + +/Since: 2.18/ +-} +optionMenuClose :: + (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> m () +optionMenuClose menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + webkit_option_menu_close menu' + touchManagedPtr menu + return () + +#if ENABLE_OVERLOADING +data OptionMenuCloseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsOptionMenu a) => O.MethodInfo OptionMenuCloseMethodInfo a signature where + overloadedMethod _ = optionMenuClose + +#endif + +-- method OptionMenu::get_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_get_item" webkit_option_menu_get_item :: + Ptr OptionMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}) + Word32 -> -- index : TBasicType TUInt + IO (Ptr WebKit2.OptionMenuItem.OptionMenuItem) + +{- | +Returns the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/. + +/Since: 2.18/ +-} +optionMenuGetItem :: + (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> Word32 + {- ^ /@index@/: the index of the item -} + -> m (Maybe WebKit2.OptionMenuItem.OptionMenuItem) + {- ^ __Returns:__ a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' of /@menu@/. -} +optionMenuGetItem menu index = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_option_menu_get_item menu' index + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed WebKit2.OptionMenuItem.OptionMenuItem) result' + return result'' + touchManagedPtr menu + return maybeResult + +#if ENABLE_OVERLOADING +data OptionMenuGetItemMethodInfo +instance (signature ~ (Word32 -> m (Maybe WebKit2.OptionMenuItem.OptionMenuItem)), MonadIO m, IsOptionMenu a) => O.MethodInfo OptionMenuGetItemMethodInfo a signature where + overloadedMethod _ = optionMenuGetItem + +#endif + +-- method OptionMenu::get_n_items +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_get_n_items" webkit_option_menu_get_n_items :: + Ptr OptionMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}) + IO Word32 + +{- | +Gets the length of the /@menu@/. + +/Since: 2.18/ +-} +optionMenuGetNItems :: + (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> m Word32 + {- ^ __Returns:__ the number of 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'\s in /@menu@/ -} +optionMenuGetNItems menu = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + result <- webkit_option_menu_get_n_items menu' + touchManagedPtr menu + return result + +#if ENABLE_OVERLOADING +data OptionMenuGetNItemsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsOptionMenu a) => O.MethodInfo OptionMenuGetNItemsMethodInfo a signature where + overloadedMethod _ = optionMenuGetNItems + +#endif + +-- method OptionMenu::select_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_select_item" webkit_option_menu_select_item :: + Ptr OptionMenu -> -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}) + Word32 -> -- index : TBasicType TUInt + IO () + +{- | +Selects the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/. Selecting an item changes the +text shown by the combo button, but it doesn\'t change the value of the element. You need to +explicitly activate the item with 'GI.WebKit2.Objects.OptionMenu.optionMenuSelectItem' or close the menu with +'GI.WebKit2.Objects.OptionMenu.optionMenuClose' in which case the currently selected item will be activated. + +/Since: 2.18/ +-} +optionMenuSelectItem :: + (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) => + a + {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> Word32 + {- ^ /@index@/: the index of the item -} + -> m () +optionMenuSelectItem menu index = liftIO $ do + menu' <- unsafeManagedPtrCastPtr menu + webkit_option_menu_select_item menu' index + touchManagedPtr menu + return () + +#if ENABLE_OVERLOADING +data OptionMenuSelectItemMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsOptionMenu a) => O.MethodInfo OptionMenuSelectItemMethodInfo a signature where + overloadedMethod _ = optionMenuSelectItem + +#endif + + diff --git a/GI/WebKit2/Objects/OptionMenu.hs-boot b/GI/WebKit2/Objects/OptionMenu.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/OptionMenu.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.OptionMenu 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 + +newtype OptionMenu = OptionMenu (ManagedPtr OptionMenu) +instance GObject OptionMenu where +class (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o +instance (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o +instance O.HasParentTypes OptionMenu +#if ENABLE_OVERLOADING +data OptionMenuCloseSignalInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuActivateItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuCloseMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuGetItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuGetNItemsMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuSelectItemMethodInfo +#endif diff --git a/GI/WebKit2/Objects/Plugin.hs b/GI/WebKit2/Objects/Plugin.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Plugin.hs @@ -0,0 +1,306 @@ + + +{- | +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.Plugin + ( + +-- * Exported types + Plugin(..) , + IsPlugin , + toPlugin , + noPlugin , + + + -- * Methods +-- ** getDescription #method:getDescription# + +#if ENABLE_OVERLOADING + PluginGetDescriptionMethodInfo , +#endif + pluginGetDescription , + + +-- ** getMimeInfoList #method:getMimeInfoList# + +#if ENABLE_OVERLOADING + PluginGetMimeInfoListMethodInfo , +#endif + pluginGetMimeInfoList , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + PluginGetNameMethodInfo , +#endif + pluginGetName , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + PluginGetPathMethodInfo , +#endif + pluginGetPath , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Structs.MimeInfo as WebKit2.MimeInfo + +-- | Memory-managed wrapper type. +newtype Plugin = Plugin (ManagedPtr Plugin) +foreign import ccall "webkit_plugin_get_type" + c_webkit_plugin_get_type :: IO GType + +instance GObject Plugin where + gobjectType = c_webkit_plugin_get_type + + +-- | Type class for types which can be safely cast to `Plugin`, for instance with `toPlugin`. +class (GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance (GObject o, O.IsDescendantOf Plugin o) => IsPlugin o + +instance O.HasParentTypes Plugin +type instance O.ParentTypes Plugin = '[GObject.Object.Object] + +-- | Cast to `Plugin`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPlugin :: (MonadIO m, IsPlugin o) => o -> m Plugin +toPlugin = liftIO . unsafeCastTo Plugin + +-- | A convenience alias for `Nothing` :: `Maybe` `Plugin`. +noPlugin :: Maybe Plugin +noPlugin = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePluginMethod (t :: Symbol) (o :: *) :: * where + ResolvePluginMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePluginMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePluginMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePluginMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePluginMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePluginMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePluginMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePluginMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePluginMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePluginMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePluginMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePluginMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePluginMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePluginMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePluginMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePluginMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePluginMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePluginMethod "getDescription" o = PluginGetDescriptionMethodInfo + ResolvePluginMethod "getMimeInfoList" o = PluginGetMimeInfoListMethodInfo + ResolvePluginMethod "getName" o = PluginGetNameMethodInfo + ResolvePluginMethod "getPath" o = PluginGetPathMethodInfo + ResolvePluginMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePluginMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePluginMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePluginMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePluginMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePluginMethod t Plugin, O.MethodInfo info Plugin p) => OL.IsLabel t (Plugin -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Plugin +type instance O.AttributeList Plugin = PluginAttributeList +type PluginAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Plugin = PluginSignalList +type PluginSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Plugin::get_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "WebKit2", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPlugin", 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_plugin_get_description" webkit_plugin_get_description :: + Ptr Plugin -> -- plugin : TInterface (Name {namespace = "WebKit2", name = "Plugin"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +pluginGetDescription :: + (B.CallStack.HasCallStack, MonadIO m, IsPlugin a) => + a + {- ^ /@plugin@/: a 'GI.WebKit2.Objects.Plugin.Plugin' -} + -> m T.Text + {- ^ __Returns:__ the description of the plugin. -} +pluginGetDescription plugin = liftIO $ do + plugin' <- unsafeManagedPtrCastPtr plugin + result <- webkit_plugin_get_description plugin' + checkUnexpectedReturnNULL "pluginGetDescription" result + result' <- cstringToText result + touchManagedPtr plugin + return result' + +#if ENABLE_OVERLOADING +data PluginGetDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.MethodInfo PluginGetDescriptionMethodInfo a signature where + overloadedMethod _ = pluginGetDescription + +#endif + +-- method Plugin::get_mime_info_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "WebKit2", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPlugin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_plugin_get_mime_info_list" webkit_plugin_get_mime_info_list :: + Ptr Plugin -> -- plugin : TInterface (Name {namespace = "WebKit2", name = "Plugin"}) + IO (Ptr (GList (Ptr WebKit2.MimeInfo.MimeInfo))) + +{- | +Get information about MIME types handled by the plugin, +as a list of 'GI.WebKit2.Structs.MimeInfo.MimeInfo'. +-} +pluginGetMimeInfoList :: + (B.CallStack.HasCallStack, MonadIO m, IsPlugin a) => + a + {- ^ /@plugin@/: a 'GI.WebKit2.Objects.Plugin.Plugin' -} + -> m [WebKit2.MimeInfo.MimeInfo] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Structs.MimeInfo.MimeInfo'. -} +pluginGetMimeInfoList plugin = liftIO $ do + plugin' <- unsafeManagedPtrCastPtr plugin + result <- webkit_plugin_get_mime_info_list plugin' + result' <- unpackGList result + result'' <- mapM (newBoxed WebKit2.MimeInfo.MimeInfo) result' + touchManagedPtr plugin + return result'' + +#if ENABLE_OVERLOADING +data PluginGetMimeInfoListMethodInfo +instance (signature ~ (m [WebKit2.MimeInfo.MimeInfo]), MonadIO m, IsPlugin a) => O.MethodInfo PluginGetMimeInfoListMethodInfo a signature where + overloadedMethod _ = pluginGetMimeInfoList + +#endif + +-- method Plugin::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "WebKit2", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPlugin", 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_plugin_get_name" webkit_plugin_get_name :: + Ptr Plugin -> -- plugin : TInterface (Name {namespace = "WebKit2", name = "Plugin"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +pluginGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsPlugin a) => + a + {- ^ /@plugin@/: a 'GI.WebKit2.Objects.Plugin.Plugin' -} + -> m T.Text + {- ^ __Returns:__ the name of the plugin. -} +pluginGetName plugin = liftIO $ do + plugin' <- unsafeManagedPtrCastPtr plugin + result <- webkit_plugin_get_name plugin' + checkUnexpectedReturnNULL "pluginGetName" result + result' <- cstringToText result + touchManagedPtr plugin + return result' + +#if ENABLE_OVERLOADING +data PluginGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.MethodInfo PluginGetNameMethodInfo a signature where + overloadedMethod _ = pluginGetName + +#endif + +-- method Plugin::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "WebKit2", name = "Plugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPlugin", 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_plugin_get_path" webkit_plugin_get_path :: + Ptr Plugin -> -- plugin : TInterface (Name {namespace = "WebKit2", name = "Plugin"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +pluginGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsPlugin a) => + a + {- ^ /@plugin@/: a 'GI.WebKit2.Objects.Plugin.Plugin' -} + -> m T.Text + {- ^ __Returns:__ the absolute path where the plugin is installed. -} +pluginGetPath plugin = liftIO $ do + plugin' <- unsafeManagedPtrCastPtr plugin + result <- webkit_plugin_get_path plugin' + checkUnexpectedReturnNULL "pluginGetPath" result + result' <- cstringToText result + touchManagedPtr plugin + return result' + +#if ENABLE_OVERLOADING +data PluginGetPathMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.MethodInfo PluginGetPathMethodInfo a signature where + overloadedMethod _ = pluginGetPath + +#endif + + diff --git a/GI/WebKit2/Objects/Plugin.hs-boot b/GI/WebKit2/Objects/Plugin.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Plugin.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.Plugin 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 + +newtype Plugin = Plugin (ManagedPtr Plugin) +instance GObject Plugin where +class (GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance (GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance O.HasParentTypes Plugin +#if ENABLE_OVERLOADING +data PluginGetDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PluginGetMimeInfoListMethodInfo +#endif +#if ENABLE_OVERLOADING +data PluginGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PluginGetPathMethodInfo +#endif diff --git a/GI/WebKit2/Objects/PolicyDecision.hs b/GI/WebKit2/Objects/PolicyDecision.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PolicyDecision.hs @@ -0,0 +1,251 @@ + + +{- | +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.PolicyDecision + ( + +-- * Exported types + PolicyDecision(..) , + IsPolicyDecision , + toPolicyDecision , + noPolicyDecision , + + + -- * Methods +-- ** download #method:download# + +#if ENABLE_OVERLOADING + PolicyDecisionDownloadMethodInfo , +#endif + policyDecisionDownload , + + +-- ** ignore #method:ignore# + +#if ENABLE_OVERLOADING + PolicyDecisionIgnoreMethodInfo , +#endif + policyDecisionIgnore , + + +-- ** use #method:use# + +#if ENABLE_OVERLOADING + PolicyDecisionUseMethodInfo , +#endif + policyDecisionUse , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype PolicyDecision = PolicyDecision (ManagedPtr PolicyDecision) +foreign import ccall "webkit_policy_decision_get_type" + c_webkit_policy_decision_get_type :: IO GType + +instance GObject PolicyDecision where + gobjectType = c_webkit_policy_decision_get_type + + +-- | Type class for types which can be safely cast to `PolicyDecision`, for instance with `toPolicyDecision`. +class (GObject o, O.IsDescendantOf PolicyDecision o) => IsPolicyDecision o +instance (GObject o, O.IsDescendantOf PolicyDecision o) => IsPolicyDecision o + +instance O.HasParentTypes PolicyDecision +type instance O.ParentTypes PolicyDecision = '[GObject.Object.Object] + +-- | Cast to `PolicyDecision`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPolicyDecision :: (MonadIO m, IsPolicyDecision o) => o -> m PolicyDecision +toPolicyDecision = liftIO . unsafeCastTo PolicyDecision + +-- | A convenience alias for `Nothing` :: `Maybe` `PolicyDecision`. +noPolicyDecision :: Maybe PolicyDecision +noPolicyDecision = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePolicyDecisionMethod (t :: Symbol) (o :: *) :: * where + ResolvePolicyDecisionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePolicyDecisionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePolicyDecisionMethod "download" o = PolicyDecisionDownloadMethodInfo + ResolvePolicyDecisionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePolicyDecisionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePolicyDecisionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePolicyDecisionMethod "ignore" o = PolicyDecisionIgnoreMethodInfo + ResolvePolicyDecisionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePolicyDecisionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePolicyDecisionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePolicyDecisionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePolicyDecisionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePolicyDecisionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePolicyDecisionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePolicyDecisionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePolicyDecisionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePolicyDecisionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePolicyDecisionMethod "use" o = PolicyDecisionUseMethodInfo + ResolvePolicyDecisionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePolicyDecisionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePolicyDecisionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePolicyDecisionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePolicyDecisionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePolicyDecisionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePolicyDecisionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePolicyDecisionMethod t PolicyDecision, O.MethodInfo info PolicyDecision p) => OL.IsLabel t (PolicyDecision -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PolicyDecision +type instance O.AttributeList PolicyDecision = PolicyDecisionAttributeList +type PolicyDecisionAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList PolicyDecision = PolicyDecisionSignalList +type PolicyDecisionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PolicyDecision::download +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_policy_decision_download" webkit_policy_decision_download :: + Ptr PolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}) + IO () + +{- | +Spawn a download from this decision. +-} +policyDecisionDownload :: + (B.CallStack.HasCallStack, MonadIO m, IsPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' -} + -> m () +policyDecisionDownload decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + webkit_policy_decision_download decision' + touchManagedPtr decision + return () + +#if ENABLE_OVERLOADING +data PolicyDecisionDownloadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPolicyDecision a) => O.MethodInfo PolicyDecisionDownloadMethodInfo a signature where + overloadedMethod _ = policyDecisionDownload + +#endif + +-- method PolicyDecision::ignore +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_policy_decision_ignore" webkit_policy_decision_ignore :: + Ptr PolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}) + IO () + +{- | +Ignore the action which triggered this decision. For instance, for a +'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision', this would cancel the request. +-} +policyDecisionIgnore :: + (B.CallStack.HasCallStack, MonadIO m, IsPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' -} + -> m () +policyDecisionIgnore decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + webkit_policy_decision_ignore decision' + touchManagedPtr decision + return () + +#if ENABLE_OVERLOADING +data PolicyDecisionIgnoreMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPolicyDecision a) => O.MethodInfo PolicyDecisionIgnoreMethodInfo a signature where + overloadedMethod _ = policyDecisionIgnore + +#endif + +-- method PolicyDecision::use +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_policy_decision_use" webkit_policy_decision_use :: + Ptr PolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "PolicyDecision"}) + IO () + +{- | +Accept the action which triggered this decision. +-} +policyDecisionUse :: + (B.CallStack.HasCallStack, MonadIO m, IsPolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' -} + -> m () +policyDecisionUse decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + webkit_policy_decision_use decision' + touchManagedPtr decision + return () + +#if ENABLE_OVERLOADING +data PolicyDecisionUseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPolicyDecision a) => O.MethodInfo PolicyDecisionUseMethodInfo a signature where + overloadedMethod _ = policyDecisionUse + +#endif + + diff --git a/GI/WebKit2/Objects/PolicyDecision.hs-boot b/GI/WebKit2/Objects/PolicyDecision.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PolicyDecision.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.PolicyDecision 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 + +newtype PolicyDecision = PolicyDecision (ManagedPtr PolicyDecision) +instance GObject PolicyDecision where +class (GObject o, O.IsDescendantOf PolicyDecision o) => IsPolicyDecision o +instance (GObject o, O.IsDescendantOf PolicyDecision o) => IsPolicyDecision o +instance O.HasParentTypes PolicyDecision +#if ENABLE_OVERLOADING +data PolicyDecisionDownloadMethodInfo +#endif +#if ENABLE_OVERLOADING +data PolicyDecisionIgnoreMethodInfo +#endif +#if ENABLE_OVERLOADING +data PolicyDecisionUseMethodInfo +#endif diff --git a/GI/WebKit2/Objects/PrintCustomWidget.hs b/GI/WebKit2/Objects/PrintCustomWidget.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PrintCustomWidget.hs @@ -0,0 +1,582 @@ + + +{- | +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.PrintCustomWidget + ( + +-- * Exported types + PrintCustomWidget(..) , + IsPrintCustomWidget , + toPrintCustomWidget , + noPrintCustomWidget , + + + -- * Methods +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + PrintCustomWidgetGetTitleMethodInfo , +#endif + printCustomWidgetGetTitle , + + +-- ** getWidget #method:getWidget# + +#if ENABLE_OVERLOADING + PrintCustomWidgetGetWidgetMethodInfo , +#endif + printCustomWidgetGetWidget , + + +-- ** new #method:new# + + printCustomWidgetNew , + + + + + -- * Properties +-- ** title #attr:title# +{- | The title of the custom widget. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + PrintCustomWidgetTitlePropertyInfo , +#endif + constructPrintCustomWidgetTitle , + getPrintCustomWidgetTitle , +#if ENABLE_OVERLOADING + printCustomWidgetTitle , +#endif + + +-- ** widget #attr:widget# +{- | The custom 'GI.Gtk.Objects.Widget.Widget' that will be embedded in the dialog. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + PrintCustomWidgetWidgetPropertyInfo , +#endif + constructPrintCustomWidgetWidget , + getPrintCustomWidgetWidget , +#if ENABLE_OVERLOADING + printCustomWidgetWidget , +#endif + + + + + -- * Signals +-- ** apply #signal:apply# + + C_PrintCustomWidgetApplyCallback , + PrintCustomWidgetApplyCallback , +#if ENABLE_OVERLOADING + PrintCustomWidgetApplySignalInfo , +#endif + afterPrintCustomWidgetApply , + genClosure_PrintCustomWidgetApply , + mk_PrintCustomWidgetApplyCallback , + noPrintCustomWidgetApplyCallback , + onPrintCustomWidgetApply , + wrap_PrintCustomWidgetApplyCallback , + + +-- ** update #signal:update# + + C_PrintCustomWidgetUpdateCallback , + PrintCustomWidgetUpdateCallback , +#if ENABLE_OVERLOADING + PrintCustomWidgetUpdateSignalInfo , +#endif + afterPrintCustomWidgetUpdate , + genClosure_PrintCustomWidgetUpdate , + mk_PrintCustomWidgetUpdateCallback , + noPrintCustomWidgetUpdateCallback , + onPrintCustomWidgetUpdate , + wrap_PrintCustomWidgetUpdateCallback , + + + + + ) 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.Gtk.Objects.PageSetup as Gtk.PageSetup +import qualified GI.Gtk.Objects.PrintSettings as Gtk.PrintSettings +import qualified GI.Gtk.Objects.Widget as Gtk.Widget + +-- | Memory-managed wrapper type. +newtype PrintCustomWidget = PrintCustomWidget (ManagedPtr PrintCustomWidget) +foreign import ccall "webkit_print_custom_widget_get_type" + c_webkit_print_custom_widget_get_type :: IO GType + +instance GObject PrintCustomWidget where + gobjectType = c_webkit_print_custom_widget_get_type + + +-- | Type class for types which can be safely cast to `PrintCustomWidget`, for instance with `toPrintCustomWidget`. +class (GObject o, O.IsDescendantOf PrintCustomWidget o) => IsPrintCustomWidget o +instance (GObject o, O.IsDescendantOf PrintCustomWidget o) => IsPrintCustomWidget o + +instance O.HasParentTypes PrintCustomWidget +type instance O.ParentTypes PrintCustomWidget = '[GObject.Object.Object] + +-- | Cast to `PrintCustomWidget`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPrintCustomWidget :: (MonadIO m, IsPrintCustomWidget o) => o -> m PrintCustomWidget +toPrintCustomWidget = liftIO . unsafeCastTo PrintCustomWidget + +-- | A convenience alias for `Nothing` :: `Maybe` `PrintCustomWidget`. +noPrintCustomWidget :: Maybe PrintCustomWidget +noPrintCustomWidget = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePrintCustomWidgetMethod (t :: Symbol) (o :: *) :: * where + ResolvePrintCustomWidgetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePrintCustomWidgetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePrintCustomWidgetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePrintCustomWidgetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePrintCustomWidgetMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePrintCustomWidgetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePrintCustomWidgetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePrintCustomWidgetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePrintCustomWidgetMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePrintCustomWidgetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePrintCustomWidgetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePrintCustomWidgetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePrintCustomWidgetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePrintCustomWidgetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePrintCustomWidgetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePrintCustomWidgetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePrintCustomWidgetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePrintCustomWidgetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePrintCustomWidgetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePrintCustomWidgetMethod "getTitle" o = PrintCustomWidgetGetTitleMethodInfo + ResolvePrintCustomWidgetMethod "getWidget" o = PrintCustomWidgetGetWidgetMethodInfo + ResolvePrintCustomWidgetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePrintCustomWidgetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePrintCustomWidgetMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePrintCustomWidgetMethod t PrintCustomWidget, O.MethodInfo info PrintCustomWidget p) => OL.IsLabel t (PrintCustomWidget -> 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 PrintCustomWidget::apply +{- | +Emitted right before the printing will start. You should read the information +from the widget and update the content based on it if necessary. The widget +is not guaranteed to be valid at a later time. + +/Since: 2.16/ +-} +type PrintCustomWidgetApplyCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `PrintCustomWidgetApplyCallback`@. +noPrintCustomWidgetApplyCallback :: Maybe PrintCustomWidgetApplyCallback +noPrintCustomWidgetApplyCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_PrintCustomWidgetApplyCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_PrintCustomWidgetApplyCallback`. +foreign import ccall "wrapper" + mk_PrintCustomWidgetApplyCallback :: C_PrintCustomWidgetApplyCallback -> IO (FunPtr C_PrintCustomWidgetApplyCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_PrintCustomWidgetApply :: MonadIO m => PrintCustomWidgetApplyCallback -> m (GClosure C_PrintCustomWidgetApplyCallback) +genClosure_PrintCustomWidgetApply cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetApplyCallback cb + mk_PrintCustomWidgetApplyCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `PrintCustomWidgetApplyCallback` into a `C_PrintCustomWidgetApplyCallback`. +wrap_PrintCustomWidgetApplyCallback :: + PrintCustomWidgetApplyCallback -> + C_PrintCustomWidgetApplyCallback +wrap_PrintCustomWidgetApplyCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@apply@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' printCustomWidget #apply callback +@ +-} +onPrintCustomWidgetApply :: (IsPrintCustomWidget a, MonadIO m) => a -> PrintCustomWidgetApplyCallback -> m SignalHandlerId +onPrintCustomWidgetApply obj cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetApplyCallback cb + cb'' <- mk_PrintCustomWidgetApplyCallback cb' + connectSignalFunPtr obj "apply" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@apply@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' printCustomWidget #apply callback +@ +-} +afterPrintCustomWidgetApply :: (IsPrintCustomWidget a, MonadIO m) => a -> PrintCustomWidgetApplyCallback -> m SignalHandlerId +afterPrintCustomWidgetApply obj cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetApplyCallback cb + cb'' <- mk_PrintCustomWidgetApplyCallback cb' + connectSignalFunPtr obj "apply" cb'' SignalConnectAfter + + +-- signal PrintCustomWidget::update +{- | +Emitted after change of selected printer in the dialog. The actual page setup +and print settings are available and the custom widget can actualize itself +according to their values. + +/Since: 2.16/ +-} +type PrintCustomWidgetUpdateCallback = + Gtk.PageSetup.PageSetup + {- ^ /@pageSetup@/: actual page setup -} + -> Gtk.PrintSettings.PrintSettings + {- ^ /@printSettings@/: actual print settings -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `PrintCustomWidgetUpdateCallback`@. +noPrintCustomWidgetUpdateCallback :: Maybe PrintCustomWidgetUpdateCallback +noPrintCustomWidgetUpdateCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_PrintCustomWidgetUpdateCallback = + Ptr () -> -- object + Ptr Gtk.PageSetup.PageSetup -> + Ptr Gtk.PrintSettings.PrintSettings -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_PrintCustomWidgetUpdateCallback`. +foreign import ccall "wrapper" + mk_PrintCustomWidgetUpdateCallback :: C_PrintCustomWidgetUpdateCallback -> IO (FunPtr C_PrintCustomWidgetUpdateCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_PrintCustomWidgetUpdate :: MonadIO m => PrintCustomWidgetUpdateCallback -> m (GClosure C_PrintCustomWidgetUpdateCallback) +genClosure_PrintCustomWidgetUpdate cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetUpdateCallback cb + mk_PrintCustomWidgetUpdateCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `PrintCustomWidgetUpdateCallback` into a `C_PrintCustomWidgetUpdateCallback`. +wrap_PrintCustomWidgetUpdateCallback :: + PrintCustomWidgetUpdateCallback -> + C_PrintCustomWidgetUpdateCallback +wrap_PrintCustomWidgetUpdateCallback _cb _ pageSetup printSettings _ = do + pageSetup' <- (newObject Gtk.PageSetup.PageSetup) pageSetup + printSettings' <- (newObject Gtk.PrintSettings.PrintSettings) printSettings + _cb pageSetup' printSettings' + + +{- | +Connect a signal handler for the “@update@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' printCustomWidget #update callback +@ +-} +onPrintCustomWidgetUpdate :: (IsPrintCustomWidget a, MonadIO m) => a -> PrintCustomWidgetUpdateCallback -> m SignalHandlerId +onPrintCustomWidgetUpdate obj cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetUpdateCallback cb + cb'' <- mk_PrintCustomWidgetUpdateCallback cb' + connectSignalFunPtr obj "update" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@update@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' printCustomWidget #update callback +@ +-} +afterPrintCustomWidgetUpdate :: (IsPrintCustomWidget a, MonadIO m) => a -> PrintCustomWidgetUpdateCallback -> m SignalHandlerId +afterPrintCustomWidgetUpdate obj cb = liftIO $ do + let cb' = wrap_PrintCustomWidgetUpdateCallback cb + cb'' <- mk_PrintCustomWidgetUpdateCallback cb' + connectSignalFunPtr obj "update" cb'' SignalConnectAfter + + +-- VVV Prop "title" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCustomWidget #title +@ +-} +getPrintCustomWidgetTitle :: (MonadIO m, IsPrintCustomWidget o) => o -> m T.Text +getPrintCustomWidgetTitle obj = liftIO $ checkUnexpectedNothing "getPrintCustomWidgetTitle" $ B.Properties.getObjectPropertyString obj "title" + +{- | +Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCustomWidgetTitle :: (IsPrintCustomWidget o) => T.Text -> IO (GValueConstruct o) +constructPrintCustomWidgetTitle val = B.Properties.constructObjectPropertyString "title" (Just val) + +#if ENABLE_OVERLOADING +data PrintCustomWidgetTitlePropertyInfo +instance AttrInfo PrintCustomWidgetTitlePropertyInfo where + type AttrAllowedOps PrintCustomWidgetTitlePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCustomWidgetTitlePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint PrintCustomWidgetTitlePropertyInfo = IsPrintCustomWidget + type AttrGetType PrintCustomWidgetTitlePropertyInfo = T.Text + type AttrLabel PrintCustomWidgetTitlePropertyInfo = "title" + type AttrOrigin PrintCustomWidgetTitlePropertyInfo = PrintCustomWidget + attrGet _ = getPrintCustomWidgetTitle + attrSet _ = undefined + attrConstruct _ = constructPrintCustomWidgetTitle + attrClear _ = undefined +#endif + +-- VVV Prop "widget" + -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@widget@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCustomWidget #widget +@ +-} +getPrintCustomWidgetWidget :: (MonadIO m, IsPrintCustomWidget o) => o -> m (Maybe Gtk.Widget.Widget) +getPrintCustomWidgetWidget obj = liftIO $ B.Properties.getObjectPropertyObject obj "widget" Gtk.Widget.Widget + +{- | +Construct a `GValueConstruct` with valid value for the “@widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCustomWidgetWidget :: (IsPrintCustomWidget o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o) +constructPrintCustomWidgetWidget val = B.Properties.constructObjectPropertyObject "widget" (Just val) + +#if ENABLE_OVERLOADING +data PrintCustomWidgetWidgetPropertyInfo +instance AttrInfo PrintCustomWidgetWidgetPropertyInfo where + type AttrAllowedOps PrintCustomWidgetWidgetPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCustomWidgetWidgetPropertyInfo = Gtk.Widget.IsWidget + type AttrBaseTypeConstraint PrintCustomWidgetWidgetPropertyInfo = IsPrintCustomWidget + type AttrGetType PrintCustomWidgetWidgetPropertyInfo = (Maybe Gtk.Widget.Widget) + type AttrLabel PrintCustomWidgetWidgetPropertyInfo = "widget" + type AttrOrigin PrintCustomWidgetWidgetPropertyInfo = PrintCustomWidget + attrGet _ = getPrintCustomWidgetWidget + attrSet _ = undefined + attrConstruct _ = constructPrintCustomWidgetWidget + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PrintCustomWidget +type instance O.AttributeList PrintCustomWidget = PrintCustomWidgetAttributeList +type PrintCustomWidgetAttributeList = ('[ '("title", PrintCustomWidgetTitlePropertyInfo), '("widget", PrintCustomWidgetWidgetPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +printCustomWidgetTitle :: AttrLabelProxy "title" +printCustomWidgetTitle = AttrLabelProxy + +printCustomWidgetWidget :: AttrLabelProxy "widget" +printCustomWidgetWidget = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data PrintCustomWidgetApplySignalInfo +instance SignalInfo PrintCustomWidgetApplySignalInfo where + type HaskellCallbackType PrintCustomWidgetApplySignalInfo = PrintCustomWidgetApplyCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_PrintCustomWidgetApplyCallback cb + cb'' <- mk_PrintCustomWidgetApplyCallback cb' + connectSignalFunPtr obj "apply" cb'' connectMode + +data PrintCustomWidgetUpdateSignalInfo +instance SignalInfo PrintCustomWidgetUpdateSignalInfo where + type HaskellCallbackType PrintCustomWidgetUpdateSignalInfo = PrintCustomWidgetUpdateCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_PrintCustomWidgetUpdateCallback cb + cb'' <- mk_PrintCustomWidgetUpdateCallback cb' + connectSignalFunPtr obj "update" cb'' connectMode + +type instance O.SignalList PrintCustomWidget = PrintCustomWidgetSignalList +type PrintCustomWidgetSignalList = ('[ '("apply", PrintCustomWidgetApplySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("update", PrintCustomWidgetUpdateSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PrintCustomWidget::new +-- method type : Constructor +-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a @widget's title", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "PrintCustomWidget"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_custom_widget_new" webkit_print_custom_widget_new :: + Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) + CString -> -- title : TBasicType TUTF8 + IO (Ptr PrintCustomWidget) + +{- | +Create a new 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget' with given /@widget@/ and /@title@/. The /@widget@/ +ownership is taken and it is destroyed together with the dialog even if this +object could still be alive at that point. You typically want to pass a container +widget with multiple widgets in it. + +/Since: 2.16/ +-} +printCustomWidgetNew :: + (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) => + a + {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -} + -> T.Text + {- ^ /@title@/: a /@widget@/\'s title -} + -> m PrintCustomWidget + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.PrintOperation.PrintOperation'. -} +printCustomWidgetNew widget title = liftIO $ do + widget' <- unsafeManagedPtrCastPtr widget + title' <- textToCString title + result <- webkit_print_custom_widget_new widget' title' + checkUnexpectedReturnNULL "printCustomWidgetNew" result + result' <- (wrapObject PrintCustomWidget) result + touchManagedPtr widget + freeMem title' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PrintCustomWidget::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_custom_widget", argType = TInterface (Name {namespace = "WebKit2", name = "PrintCustomWidget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintCustomWidget", 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_print_custom_widget_get_title" webkit_print_custom_widget_get_title :: + Ptr PrintCustomWidget -> -- print_custom_widget : TInterface (Name {namespace = "WebKit2", name = "PrintCustomWidget"}) + IO CString + +{- | +Return the value of 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget':@/title/@ property for the given +/@printCustomWidget@/ object. + +/Since: 2.16/ +-} +printCustomWidgetGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCustomWidget a) => + a + {- ^ /@printCustomWidget@/: a 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget' -} + -> m T.Text + {- ^ __Returns:__ Title of the /@printCustomWidget@/. -} +printCustomWidgetGetTitle printCustomWidget = liftIO $ do + printCustomWidget' <- unsafeManagedPtrCastPtr printCustomWidget + result <- webkit_print_custom_widget_get_title printCustomWidget' + checkUnexpectedReturnNULL "printCustomWidgetGetTitle" result + result' <- cstringToText result + touchManagedPtr printCustomWidget + return result' + +#if ENABLE_OVERLOADING +data PrintCustomWidgetGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPrintCustomWidget a) => O.MethodInfo PrintCustomWidgetGetTitleMethodInfo a signature where + overloadedMethod _ = printCustomWidgetGetTitle + +#endif + +-- method PrintCustomWidget::get_widget +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_custom_widget", argType = TInterface (Name {namespace = "WebKit2", name = "PrintCustomWidget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintCustomWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_custom_widget_get_widget" webkit_print_custom_widget_get_widget :: + Ptr PrintCustomWidget -> -- print_custom_widget : TInterface (Name {namespace = "WebKit2", name = "PrintCustomWidget"}) + IO (Ptr Gtk.Widget.Widget) + +{- | +Return the value of 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget':@/widget/@ property for the given +/@printCustomWidget@/ object. The returned value will always be valid if called +from 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget'::@/apply/@ or 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget'::@/update/@ +callbacks, but it will be 'Nothing' if called after the +'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget'::@/apply/@ signal is emitted. + +/Since: 2.16/ +-} +printCustomWidgetGetWidget :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCustomWidget a) => + a + {- ^ /@printCustomWidget@/: a 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget' -} + -> m (Maybe Gtk.Widget.Widget) + {- ^ __Returns:__ a 'GI.Gtk.Objects.Widget.Widget'. -} +printCustomWidgetGetWidget printCustomWidget = liftIO $ do + printCustomWidget' <- unsafeManagedPtrCastPtr printCustomWidget + result <- webkit_print_custom_widget_get_widget printCustomWidget' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.Widget.Widget) result' + return result'' + touchManagedPtr printCustomWidget + return maybeResult + +#if ENABLE_OVERLOADING +data PrintCustomWidgetGetWidgetMethodInfo +instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsPrintCustomWidget a) => O.MethodInfo PrintCustomWidgetGetWidgetMethodInfo a signature where + overloadedMethod _ = printCustomWidgetGetWidget + +#endif + + diff --git a/GI/WebKit2/Objects/PrintCustomWidget.hs-boot b/GI/WebKit2/Objects/PrintCustomWidget.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PrintCustomWidget.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.PrintCustomWidget 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 + +newtype PrintCustomWidget = PrintCustomWidget (ManagedPtr PrintCustomWidget) +instance GObject PrintCustomWidget where +class (GObject o, O.IsDescendantOf PrintCustomWidget o) => IsPrintCustomWidget o +instance (GObject o, O.IsDescendantOf PrintCustomWidget o) => IsPrintCustomWidget o +instance O.HasParentTypes PrintCustomWidget +#if ENABLE_OVERLOADING +data PrintCustomWidgetTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCustomWidgetWidgetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCustomWidgetApplySignalInfo +#endif +#if ENABLE_OVERLOADING +data PrintCustomWidgetUpdateSignalInfo +#endif +#if ENABLE_OVERLOADING +data PrintCustomWidgetGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCustomWidgetGetWidgetMethodInfo +#endif diff --git a/GI/WebKit2/Objects/PrintOperation.hs b/GI/WebKit2/Objects/PrintOperation.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PrintOperation.hs @@ -0,0 +1,940 @@ + + +{- | +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.PrintOperation + ( + +-- * Exported types + PrintOperation(..) , + IsPrintOperation , + toPrintOperation , + noPrintOperation , + + + -- * Methods +-- ** getPageSetup #method:getPageSetup# + +#if ENABLE_OVERLOADING + PrintOperationGetPageSetupMethodInfo , +#endif + printOperationGetPageSetup , + + +-- ** getPrintSettings #method:getPrintSettings# + +#if ENABLE_OVERLOADING + PrintOperationGetPrintSettingsMethodInfo, +#endif + printOperationGetPrintSettings , + + +-- ** new #method:new# + + printOperationNew , + + +-- ** print #method:print# + +#if ENABLE_OVERLOADING + PrintOperationPrintMethodInfo , +#endif + printOperationPrint , + + +-- ** runDialog #method:runDialog# + +#if ENABLE_OVERLOADING + PrintOperationRunDialogMethodInfo , +#endif + printOperationRunDialog , + + +-- ** setPageSetup #method:setPageSetup# + +#if ENABLE_OVERLOADING + PrintOperationSetPageSetupMethodInfo , +#endif + printOperationSetPageSetup , + + +-- ** setPrintSettings #method:setPrintSettings# + +#if ENABLE_OVERLOADING + PrintOperationSetPrintSettingsMethodInfo, +#endif + printOperationSetPrintSettings , + + + + + -- * Properties +-- ** pageSetup #attr:pageSetup# +{- | The initial 'GI.Gtk.Objects.PageSetup.PageSetup' for the print operation. +-} +#if ENABLE_OVERLOADING + PrintOperationPageSetupPropertyInfo , +#endif + constructPrintOperationPageSetup , + getPrintOperationPageSetup , +#if ENABLE_OVERLOADING + printOperationPageSetup , +#endif + setPrintOperationPageSetup , + + +-- ** printSettings #attr:printSettings# +{- | The initial 'GI.Gtk.Objects.PrintSettings.PrintSettings' for the print operation. +-} +#if ENABLE_OVERLOADING + PrintOperationPrintSettingsPropertyInfo , +#endif + constructPrintOperationPrintSettings , + getPrintOperationPrintSettings , +#if ENABLE_OVERLOADING + printOperationPrintSettings , +#endif + setPrintOperationPrintSettings , + + +-- ** webView #attr:webView# +{- | The 'GI.WebKit2.Objects.WebView.WebView' that will be printed. +-} +#if ENABLE_OVERLOADING + PrintOperationWebViewPropertyInfo , +#endif + constructPrintOperationWebView , + getPrintOperationWebView , +#if ENABLE_OVERLOADING + printOperationWebView , +#endif + + + + + -- * Signals +-- ** createCustomWidget #signal:createCustomWidget# + + C_PrintOperationCreateCustomWidgetCallback, + PrintOperationCreateCustomWidgetCallback, +#if ENABLE_OVERLOADING + PrintOperationCreateCustomWidgetSignalInfo, +#endif + afterPrintOperationCreateCustomWidget , + genClosure_PrintOperationCreateCustomWidget, + mk_PrintOperationCreateCustomWidgetCallback, + noPrintOperationCreateCustomWidgetCallback, + onPrintOperationCreateCustomWidget , + wrap_PrintOperationCreateCustomWidgetCallback, + + +-- ** failed #signal:failed# + + C_PrintOperationFailedCallback , + PrintOperationFailedCallback , +#if ENABLE_OVERLOADING + PrintOperationFailedSignalInfo , +#endif + afterPrintOperationFailed , + genClosure_PrintOperationFailed , + mk_PrintOperationFailedCallback , + noPrintOperationFailedCallback , + onPrintOperationFailed , + wrap_PrintOperationFailedCallback , + + +-- ** finished #signal:finished# + + C_PrintOperationFinishedCallback , + PrintOperationFinishedCallback , +#if ENABLE_OVERLOADING + PrintOperationFinishedSignalInfo , +#endif + afterPrintOperationFinished , + genClosure_PrintOperationFinished , + mk_PrintOperationFinishedCallback , + noPrintOperationFinishedCallback , + onPrintOperationFinished , + wrap_PrintOperationFinishedCallback , + + + + + ) 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.Gtk.Objects.PageSetup as Gtk.PageSetup +import qualified GI.Gtk.Objects.PrintSettings as Gtk.PrintSettings +import qualified GI.Gtk.Objects.Window as Gtk.Window +import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Objects.PrintCustomWidget as WebKit2.PrintCustomWidget +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView + +-- | Memory-managed wrapper type. +newtype PrintOperation = PrintOperation (ManagedPtr PrintOperation) +foreign import ccall "webkit_print_operation_get_type" + c_webkit_print_operation_get_type :: IO GType + +instance GObject PrintOperation where + gobjectType = c_webkit_print_operation_get_type + + +-- | Type class for types which can be safely cast to `PrintOperation`, for instance with `toPrintOperation`. +class (GObject o, O.IsDescendantOf PrintOperation o) => IsPrintOperation o +instance (GObject o, O.IsDescendantOf PrintOperation o) => IsPrintOperation o + +instance O.HasParentTypes PrintOperation +type instance O.ParentTypes PrintOperation = '[GObject.Object.Object] + +-- | Cast to `PrintOperation`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPrintOperation :: (MonadIO m, IsPrintOperation o) => o -> m PrintOperation +toPrintOperation = liftIO . unsafeCastTo PrintOperation + +-- | A convenience alias for `Nothing` :: `Maybe` `PrintOperation`. +noPrintOperation :: Maybe PrintOperation +noPrintOperation = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePrintOperationMethod (t :: Symbol) (o :: *) :: * where + ResolvePrintOperationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePrintOperationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePrintOperationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePrintOperationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePrintOperationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePrintOperationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePrintOperationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePrintOperationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePrintOperationMethod "print" o = PrintOperationPrintMethodInfo + ResolvePrintOperationMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePrintOperationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePrintOperationMethod "runDialog" o = PrintOperationRunDialogMethodInfo + ResolvePrintOperationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePrintOperationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePrintOperationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePrintOperationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePrintOperationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePrintOperationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePrintOperationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePrintOperationMethod "getPageSetup" o = PrintOperationGetPageSetupMethodInfo + ResolvePrintOperationMethod "getPrintSettings" o = PrintOperationGetPrintSettingsMethodInfo + ResolvePrintOperationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePrintOperationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePrintOperationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePrintOperationMethod "setPageSetup" o = PrintOperationSetPageSetupMethodInfo + ResolvePrintOperationMethod "setPrintSettings" o = PrintOperationSetPrintSettingsMethodInfo + ResolvePrintOperationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePrintOperationMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePrintOperationMethod t PrintOperation, O.MethodInfo info PrintOperation p) => OL.IsLabel t (PrintOperation -> 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 PrintOperation::create-custom-widget +{- | +Emitted when displaying the print dialog with 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog'. +The returned 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget' will be added to the print dialog and +it will be owned by the /@printOperation@/. However, the object is guaranteed +to be alive until the 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget'::@/apply/@ is emitted. + +/Since: 2.16/ +-} +type PrintOperationCreateCustomWidgetCallback = + IO WebKit2.PrintCustomWidget.PrintCustomWidget + {- ^ __Returns:__ A 'GI.WebKit2.Objects.PrintCustomWidget.PrintCustomWidget' that will be embedded in the dialog. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `PrintOperationCreateCustomWidgetCallback`@. +noPrintOperationCreateCustomWidgetCallback :: Maybe PrintOperationCreateCustomWidgetCallback +noPrintOperationCreateCustomWidgetCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_PrintOperationCreateCustomWidgetCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO (Ptr WebKit2.PrintCustomWidget.PrintCustomWidget) + +-- | Generate a function pointer callable from C code, from a `C_PrintOperationCreateCustomWidgetCallback`. +foreign import ccall "wrapper" + mk_PrintOperationCreateCustomWidgetCallback :: C_PrintOperationCreateCustomWidgetCallback -> IO (FunPtr C_PrintOperationCreateCustomWidgetCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_PrintOperationCreateCustomWidget :: MonadIO m => PrintOperationCreateCustomWidgetCallback -> m (GClosure C_PrintOperationCreateCustomWidgetCallback) +genClosure_PrintOperationCreateCustomWidget cb = liftIO $ do + let cb' = wrap_PrintOperationCreateCustomWidgetCallback cb + mk_PrintOperationCreateCustomWidgetCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `PrintOperationCreateCustomWidgetCallback` into a `C_PrintOperationCreateCustomWidgetCallback`. +wrap_PrintOperationCreateCustomWidgetCallback :: + PrintOperationCreateCustomWidgetCallback -> + C_PrintOperationCreateCustomWidgetCallback +wrap_PrintOperationCreateCustomWidgetCallback _cb _ _ = do + result <- _cb + result' <- B.ManagedPtr.disownObject result + return result' + + +{- | +Connect a signal handler for the “@create-custom-widget@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' printOperation #createCustomWidget callback +@ +-} +onPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationCreateCustomWidgetCallback -> m SignalHandlerId +onPrintOperationCreateCustomWidget obj cb = liftIO $ do + let cb' = wrap_PrintOperationCreateCustomWidgetCallback cb + cb'' <- mk_PrintOperationCreateCustomWidgetCallback cb' + connectSignalFunPtr obj "create-custom-widget" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@create-custom-widget@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' printOperation #createCustomWidget callback +@ +-} +afterPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationCreateCustomWidgetCallback -> m SignalHandlerId +afterPrintOperationCreateCustomWidget obj cb = liftIO $ do + let cb' = wrap_PrintOperationCreateCustomWidgetCallback cb + cb'' <- mk_PrintOperationCreateCustomWidgetCallback cb' + connectSignalFunPtr obj "create-custom-widget" cb'' SignalConnectAfter + + +-- signal PrintOperation::failed +{- | +Emitted when an error occurs while printing. The given /@error@/, of the domain +@/WEBKIT_PRINT_ERROR/@, contains further details of the failure. +The 'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/finished/@ signal is emitted after this one. +-} +type PrintOperationFailedCallback = + GError + {- ^ /@error@/: the 'GError' that was triggered -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `PrintOperationFailedCallback`@. +noPrintOperationFailedCallback :: Maybe PrintOperationFailedCallback +noPrintOperationFailedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_PrintOperationFailedCallback = + Ptr () -> -- object + Ptr GError -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_PrintOperationFailedCallback`. +foreign import ccall "wrapper" + mk_PrintOperationFailedCallback :: C_PrintOperationFailedCallback -> IO (FunPtr C_PrintOperationFailedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_PrintOperationFailed :: MonadIO m => PrintOperationFailedCallback -> m (GClosure C_PrintOperationFailedCallback) +genClosure_PrintOperationFailed cb = liftIO $ do + let cb' = wrap_PrintOperationFailedCallback cb + mk_PrintOperationFailedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `PrintOperationFailedCallback` into a `C_PrintOperationFailedCallback`. +wrap_PrintOperationFailedCallback :: + PrintOperationFailedCallback -> + C_PrintOperationFailedCallback +wrap_PrintOperationFailedCallback _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' printOperation #failed callback +@ +-} +onPrintOperationFailed :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationFailedCallback -> m SignalHandlerId +onPrintOperationFailed obj cb = liftIO $ do + let cb' = wrap_PrintOperationFailedCallback cb + cb'' <- mk_PrintOperationFailedCallback 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' printOperation #failed callback +@ +-} +afterPrintOperationFailed :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationFailedCallback -> m SignalHandlerId +afterPrintOperationFailed obj cb = liftIO $ do + let cb' = wrap_PrintOperationFailedCallback cb + cb'' <- mk_PrintOperationFailedCallback cb' + connectSignalFunPtr obj "failed" cb'' SignalConnectAfter + + +-- signal PrintOperation::finished +{- | +Emitted when the print operation has finished doing everything +required for printing. +-} +type PrintOperationFinishedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `PrintOperationFinishedCallback`@. +noPrintOperationFinishedCallback :: Maybe PrintOperationFinishedCallback +noPrintOperationFinishedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_PrintOperationFinishedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_PrintOperationFinishedCallback`. +foreign import ccall "wrapper" + mk_PrintOperationFinishedCallback :: C_PrintOperationFinishedCallback -> IO (FunPtr C_PrintOperationFinishedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_PrintOperationFinished :: MonadIO m => PrintOperationFinishedCallback -> m (GClosure C_PrintOperationFinishedCallback) +genClosure_PrintOperationFinished cb = liftIO $ do + let cb' = wrap_PrintOperationFinishedCallback cb + mk_PrintOperationFinishedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `PrintOperationFinishedCallback` into a `C_PrintOperationFinishedCallback`. +wrap_PrintOperationFinishedCallback :: + PrintOperationFinishedCallback -> + C_PrintOperationFinishedCallback +wrap_PrintOperationFinishedCallback _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' printOperation #finished callback +@ +-} +onPrintOperationFinished :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationFinishedCallback -> m SignalHandlerId +onPrintOperationFinished obj cb = liftIO $ do + let cb' = wrap_PrintOperationFinishedCallback cb + cb'' <- mk_PrintOperationFinishedCallback 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' printOperation #finished callback +@ +-} +afterPrintOperationFinished :: (IsPrintOperation a, MonadIO m) => a -> PrintOperationFinishedCallback -> m SignalHandlerId +afterPrintOperationFinished obj cb = liftIO $ do + let cb' = wrap_PrintOperationFinishedCallback cb + cb'' <- mk_PrintOperationFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' SignalConnectAfter + + +-- VVV Prop "page-setup" + -- Type: TInterface (Name {namespace = "Gtk", name = "PageSetup"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@page-setup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printOperation #pageSetup +@ +-} +getPrintOperationPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Gtk.PageSetup.PageSetup) +getPrintOperationPageSetup obj = liftIO $ B.Properties.getObjectPropertyObject obj "page-setup" Gtk.PageSetup.PageSetup + +{- | +Set the value of the “@page-setup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printOperation [ #pageSetup 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintOperationPageSetup :: (MonadIO m, IsPrintOperation o, Gtk.PageSetup.IsPageSetup a) => o -> a -> m () +setPrintOperationPageSetup obj val = liftIO $ B.Properties.setObjectPropertyObject obj "page-setup" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@page-setup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintOperationPageSetup :: (IsPrintOperation o, Gtk.PageSetup.IsPageSetup a) => a -> IO (GValueConstruct o) +constructPrintOperationPageSetup val = B.Properties.constructObjectPropertyObject "page-setup" (Just val) + +#if ENABLE_OVERLOADING +data PrintOperationPageSetupPropertyInfo +instance AttrInfo PrintOperationPageSetupPropertyInfo where + type AttrAllowedOps PrintOperationPageSetupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintOperationPageSetupPropertyInfo = Gtk.PageSetup.IsPageSetup + type AttrBaseTypeConstraint PrintOperationPageSetupPropertyInfo = IsPrintOperation + type AttrGetType PrintOperationPageSetupPropertyInfo = (Maybe Gtk.PageSetup.PageSetup) + type AttrLabel PrintOperationPageSetupPropertyInfo = "page-setup" + type AttrOrigin PrintOperationPageSetupPropertyInfo = PrintOperation + attrGet _ = getPrintOperationPageSetup + attrSet _ = setPrintOperationPageSetup + attrConstruct _ = constructPrintOperationPageSetup + attrClear _ = undefined +#endif + +-- VVV Prop "print-settings" + -- Type: TInterface (Name {namespace = "Gtk", name = "PrintSettings"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@print-settings@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printOperation #printSettings +@ +-} +getPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Gtk.PrintSettings.PrintSettings) +getPrintOperationPrintSettings obj = liftIO $ B.Properties.getObjectPropertyObject obj "print-settings" Gtk.PrintSettings.PrintSettings + +{- | +Set the value of the “@print-settings@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printOperation [ #printSettings 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o, Gtk.PrintSettings.IsPrintSettings a) => o -> a -> m () +setPrintOperationPrintSettings obj val = liftIO $ B.Properties.setObjectPropertyObject obj "print-settings" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@print-settings@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintOperationPrintSettings :: (IsPrintOperation o, Gtk.PrintSettings.IsPrintSettings a) => a -> IO (GValueConstruct o) +constructPrintOperationPrintSettings val = B.Properties.constructObjectPropertyObject "print-settings" (Just val) + +#if ENABLE_OVERLOADING +data PrintOperationPrintSettingsPropertyInfo +instance AttrInfo PrintOperationPrintSettingsPropertyInfo where + type AttrAllowedOps PrintOperationPrintSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintOperationPrintSettingsPropertyInfo = Gtk.PrintSettings.IsPrintSettings + type AttrBaseTypeConstraint PrintOperationPrintSettingsPropertyInfo = IsPrintOperation + type AttrGetType PrintOperationPrintSettingsPropertyInfo = (Maybe Gtk.PrintSettings.PrintSettings) + type AttrLabel PrintOperationPrintSettingsPropertyInfo = "print-settings" + type AttrOrigin PrintOperationPrintSettingsPropertyInfo = PrintOperation + attrGet _ = getPrintOperationPrintSettings + attrSet _ = setPrintOperationPrintSettings + attrConstruct _ = constructPrintOperationPrintSettings + attrClear _ = undefined +#endif + +-- VVV Prop "web-view" + -- Type: TInterface (Name {namespace = "WebKit2", name = "WebView"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@web-view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printOperation #webView +@ +-} +getPrintOperationWebView :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe WebKit2.WebView.WebView) +getPrintOperationWebView obj = liftIO $ B.Properties.getObjectPropertyObject obj "web-view" WebKit2.WebView.WebView + +{- | +Construct a `GValueConstruct` with valid value for the “@web-view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintOperationWebView :: (IsPrintOperation o, WebKit2.WebView.IsWebView a) => a -> IO (GValueConstruct o) +constructPrintOperationWebView val = B.Properties.constructObjectPropertyObject "web-view" (Just val) + +#if ENABLE_OVERLOADING +data PrintOperationWebViewPropertyInfo +instance AttrInfo PrintOperationWebViewPropertyInfo where + type AttrAllowedOps PrintOperationWebViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintOperationWebViewPropertyInfo = WebKit2.WebView.IsWebView + type AttrBaseTypeConstraint PrintOperationWebViewPropertyInfo = IsPrintOperation + type AttrGetType PrintOperationWebViewPropertyInfo = (Maybe WebKit2.WebView.WebView) + type AttrLabel PrintOperationWebViewPropertyInfo = "web-view" + type AttrOrigin PrintOperationWebViewPropertyInfo = PrintOperation + attrGet _ = getPrintOperationWebView + attrSet _ = undefined + attrConstruct _ = constructPrintOperationWebView + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PrintOperation +type instance O.AttributeList PrintOperation = PrintOperationAttributeList +type PrintOperationAttributeList = ('[ '("pageSetup", PrintOperationPageSetupPropertyInfo), '("printSettings", PrintOperationPrintSettingsPropertyInfo), '("webView", PrintOperationWebViewPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +printOperationPageSetup :: AttrLabelProxy "pageSetup" +printOperationPageSetup = AttrLabelProxy + +printOperationPrintSettings :: AttrLabelProxy "printSettings" +printOperationPrintSettings = AttrLabelProxy + +printOperationWebView :: AttrLabelProxy "webView" +printOperationWebView = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data PrintOperationCreateCustomWidgetSignalInfo +instance SignalInfo PrintOperationCreateCustomWidgetSignalInfo where + type HaskellCallbackType PrintOperationCreateCustomWidgetSignalInfo = PrintOperationCreateCustomWidgetCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_PrintOperationCreateCustomWidgetCallback cb + cb'' <- mk_PrintOperationCreateCustomWidgetCallback cb' + connectSignalFunPtr obj "create-custom-widget" cb'' connectMode + +data PrintOperationFailedSignalInfo +instance SignalInfo PrintOperationFailedSignalInfo where + type HaskellCallbackType PrintOperationFailedSignalInfo = PrintOperationFailedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_PrintOperationFailedCallback cb + cb'' <- mk_PrintOperationFailedCallback cb' + connectSignalFunPtr obj "failed" cb'' connectMode + +data PrintOperationFinishedSignalInfo +instance SignalInfo PrintOperationFinishedSignalInfo where + type HaskellCallbackType PrintOperationFinishedSignalInfo = PrintOperationFinishedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_PrintOperationFinishedCallback cb + cb'' <- mk_PrintOperationFinishedCallback cb' + connectSignalFunPtr obj "finished" cb'' connectMode + +type instance O.SignalList PrintOperation = PrintOperationSignalList +type PrintOperationSignalList = ('[ '("createCustomWidget", PrintOperationCreateCustomWidgetSignalInfo), '("failed", PrintOperationFailedSignalInfo), '("finished", PrintOperationFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PrintOperation::new +-- method type : Constructor +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "PrintOperation"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_new" webkit_print_operation_new :: + Ptr WebKit2.WebView.WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr PrintOperation) + +{- | +Create a new 'GI.WebKit2.Objects.PrintOperation.PrintOperation' to print /@webView@/ contents. +-} +printOperationNew :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.WebView.IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m PrintOperation + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.PrintOperation.PrintOperation'. -} +printOperationNew webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_print_operation_new webView' + checkUnexpectedReturnNULL "printOperationNew" result + result' <- (wrapObject PrintOperation) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PrintOperation::get_page_setup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PageSetup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_get_page_setup" webkit_print_operation_get_page_setup :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + IO (Ptr Gtk.PageSetup.PageSetup) + +{- | +Return the current page setup of /@printOperation@/. It returns 'Nothing' until +either 'GI.WebKit2.Objects.PrintOperation.printOperationSetPageSetup' or 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog' +have been called. +-} +printOperationGetPageSetup :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> m (Maybe Gtk.PageSetup.PageSetup) + {- ^ __Returns:__ the current 'GI.Gtk.Objects.PageSetup.PageSetup' of /@printOperation@/. -} +printOperationGetPageSetup printOperation = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + result <- webkit_print_operation_get_page_setup printOperation' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.PageSetup.PageSetup) result' + return result'' + touchManagedPtr printOperation + return maybeResult + +#if ENABLE_OVERLOADING +data PrintOperationGetPageSetupMethodInfo +instance (signature ~ (m (Maybe Gtk.PageSetup.PageSetup)), MonadIO m, IsPrintOperation a) => O.MethodInfo PrintOperationGetPageSetupMethodInfo a signature where + overloadedMethod _ = printOperationGetPageSetup + +#endif + +-- method PrintOperation::get_print_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PrintSettings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_get_print_settings" webkit_print_operation_get_print_settings :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + IO (Ptr Gtk.PrintSettings.PrintSettings) + +{- | +Return the current print settings of /@printOperation@/. It returns 'Nothing' until +either 'GI.WebKit2.Objects.PrintOperation.printOperationSetPrintSettings' or 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog' +have been called. +-} +printOperationGetPrintSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> m (Maybe Gtk.PrintSettings.PrintSettings) + {- ^ __Returns:__ the current 'GI.Gtk.Objects.PrintSettings.PrintSettings' of /@printOperation@/. -} +printOperationGetPrintSettings printOperation = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + result <- webkit_print_operation_get_print_settings printOperation' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.PrintSettings.PrintSettings) result' + return result'' + touchManagedPtr printOperation + return maybeResult + +#if ENABLE_OVERLOADING +data PrintOperationGetPrintSettingsMethodInfo +instance (signature ~ (m (Maybe Gtk.PrintSettings.PrintSettings)), MonadIO m, IsPrintOperation a) => O.MethodInfo PrintOperationGetPrintSettingsMethodInfo a signature where + overloadedMethod _ = printOperationGetPrintSettings + +#endif + +-- method PrintOperation::print +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_print" webkit_print_operation_print :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + IO () + +{- | +Start a print operation using current print settings and page setup +without showing the print dialog. If either print settings or page setup +are not set with 'GI.WebKit2.Objects.PrintOperation.printOperationSetPrintSettings' and +'GI.WebKit2.Objects.PrintOperation.printOperationSetPageSetup', the default options will be used +and the print job will be sent to the default printer. +The 'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/finished/@ signal is emitted when the printing +operation finishes. If an error occurs while printing the signal +'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/failed/@ is emitted before 'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/finished/@. +-} +printOperationPrint :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> m () +printOperationPrint printOperation = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + webkit_print_operation_print printOperation' + touchManagedPtr printOperation + return () + +#if ENABLE_OVERLOADING +data PrintOperationPrintMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPrintOperation a) => O.MethodInfo PrintOperationPrintMethodInfo a signature where + overloadedMethod _ = printOperationPrint + +#endif + +-- method PrintOperation::run_dialog +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gtk", name = "Window"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "transient parent of the print dialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "PrintOperationResponse"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_run_dialog" webkit_print_operation_run_dialog :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + Ptr Gtk.Window.Window -> -- parent : TInterface (Name {namespace = "Gtk", name = "Window"}) + IO CUInt + +{- | +Run the print dialog and start printing using the options selected by +the user. This method returns when the print dialog is closed. +If the print dialog is cancelled 'GI.WebKit2.Enums.PrintOperationResponseCancel' +is returned. If the user clicks on the print button, 'GI.WebKit2.Enums.PrintOperationResponsePrint' +is returned and the print operation starts. In this case, the 'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/finished/@ +signal is emitted when the operation finishes. If an error occurs while printing, the signal +'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/failed/@ is emitted before 'GI.WebKit2.Objects.PrintOperation.PrintOperation'::@/finished/@. +If the print dialog is not cancelled current print settings and page setup of /@printOperation@/ +are updated with options selected by the user when Print button is pressed in print dialog. +You can get the updated print settings and page setup by calling +'GI.WebKit2.Objects.PrintOperation.printOperationGetPrintSettings' and 'GI.WebKit2.Objects.PrintOperation.printOperationGetPageSetup' +after this method. +-} +printOperationRunDialog :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a, Gtk.Window.IsWindow b) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> Maybe (b) + {- ^ /@parent@/: transient parent of the print dialog -} + -> m WebKit2.Enums.PrintOperationResponse + {- ^ __Returns:__ the 'GI.WebKit2.Enums.PrintOperationResponse' of the print dialog -} +printOperationRunDialog printOperation parent = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + maybeParent <- case parent of + Nothing -> return nullPtr + Just jParent -> do + jParent' <- unsafeManagedPtrCastPtr jParent + return jParent' + result <- webkit_print_operation_run_dialog printOperation' maybeParent + let result' = (toEnum . fromIntegral) result + touchManagedPtr printOperation + whenJust parent touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data PrintOperationRunDialogMethodInfo +instance (signature ~ (Maybe (b) -> m WebKit2.Enums.PrintOperationResponse), MonadIO m, IsPrintOperation a, Gtk.Window.IsWindow b) => O.MethodInfo PrintOperationRunDialogMethodInfo a signature where + overloadedMethod _ = printOperationRunDialog + +#endif + +-- method PrintOperation::set_page_setup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "page_setup", argType = TInterface (Name {namespace = "Gtk", name = "PageSetup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkPageSetup to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_set_page_setup" webkit_print_operation_set_page_setup :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + Ptr Gtk.PageSetup.PageSetup -> -- page_setup : TInterface (Name {namespace = "Gtk", name = "PageSetup"}) + IO () + +{- | +Set the current page setup of /@printOperation@/. Current page setup is used for the +initial values of the print dialog when 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog' is called. +-} +printOperationSetPageSetup :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a, Gtk.PageSetup.IsPageSetup b) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> b + {- ^ /@pageSetup@/: a 'GI.Gtk.Objects.PageSetup.PageSetup' to set -} + -> m () +printOperationSetPageSetup printOperation pageSetup = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + pageSetup' <- unsafeManagedPtrCastPtr pageSetup + webkit_print_operation_set_page_setup printOperation' pageSetup' + touchManagedPtr printOperation + touchManagedPtr pageSetup + return () + +#if ENABLE_OVERLOADING +data PrintOperationSetPageSetupMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsPrintOperation a, Gtk.PageSetup.IsPageSetup b) => O.MethodInfo PrintOperationSetPageSetupMethodInfo a signature where + overloadedMethod _ = printOperationSetPageSetup + +#endif + +-- method PrintOperation::set_print_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "print_operation", argType = TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitPrintOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "print_settings", argType = TInterface (Name {namespace = "Gtk", name = "PrintSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkPrintSettings to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_print_operation_set_print_settings" webkit_print_operation_set_print_settings :: + Ptr PrintOperation -> -- print_operation : TInterface (Name {namespace = "WebKit2", name = "PrintOperation"}) + Ptr Gtk.PrintSettings.PrintSettings -> -- print_settings : TInterface (Name {namespace = "Gtk", name = "PrintSettings"}) + IO () + +{- | +Set the current print settings of /@printOperation@/. Current print settings are used for +the initial values of the print dialog when 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog' is called. +-} +printOperationSetPrintSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintOperation a, Gtk.PrintSettings.IsPrintSettings b) => + a + {- ^ /@printOperation@/: a 'GI.WebKit2.Objects.PrintOperation.PrintOperation' -} + -> b + {- ^ /@printSettings@/: a 'GI.Gtk.Objects.PrintSettings.PrintSettings' to set -} + -> m () +printOperationSetPrintSettings printOperation printSettings = liftIO $ do + printOperation' <- unsafeManagedPtrCastPtr printOperation + printSettings' <- unsafeManagedPtrCastPtr printSettings + webkit_print_operation_set_print_settings printOperation' printSettings' + touchManagedPtr printOperation + touchManagedPtr printSettings + return () + +#if ENABLE_OVERLOADING +data PrintOperationSetPrintSettingsMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsPrintOperation a, Gtk.PrintSettings.IsPrintSettings b) => O.MethodInfo PrintOperationSetPrintSettingsMethodInfo a signature where + overloadedMethod _ = printOperationSetPrintSettings + +#endif + + diff --git a/GI/WebKit2/Objects/PrintOperation.hs-boot b/GI/WebKit2/Objects/PrintOperation.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/PrintOperation.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.PrintOperation 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 + +newtype PrintOperation = PrintOperation (ManagedPtr PrintOperation) +instance GObject PrintOperation where +class (GObject o, O.IsDescendantOf PrintOperation o) => IsPrintOperation o +instance (GObject o, O.IsDescendantOf PrintOperation o) => IsPrintOperation o +instance O.HasParentTypes PrintOperation +#if ENABLE_OVERLOADING +data PrintOperationPageSetupPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationPrintSettingsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationWebViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationCreateCustomWidgetSignalInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationFailedSignalInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationFinishedSignalInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationGetPageSetupMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationGetPrintSettingsMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationPrintMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationRunDialogMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationSetPageSetupMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintOperationSetPrintSettingsMethodInfo +#endif diff --git a/GI/WebKit2/Objects/ResponsePolicyDecision.hs b/GI/WebKit2/Objects/ResponsePolicyDecision.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ResponsePolicyDecision.hs @@ -0,0 +1,369 @@ + + +{- | +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.ResponsePolicyDecision + ( + +-- * Exported types + ResponsePolicyDecision(..) , + IsResponsePolicyDecision , + toResponsePolicyDecision , + noResponsePolicyDecision , + + + -- * Methods +-- ** getRequest #method:getRequest# + +#if ENABLE_OVERLOADING + ResponsePolicyDecisionGetRequestMethodInfo, +#endif + responsePolicyDecisionGetRequest , + + +-- ** getResponse #method:getResponse# + +#if ENABLE_OVERLOADING + ResponsePolicyDecisionGetResponseMethodInfo, +#endif + responsePolicyDecisionGetResponse , + + +-- ** isMimeTypeSupported #method:isMimeTypeSupported# + +#if ENABLE_OVERLOADING + ResponsePolicyDecisionIsMimeTypeSupportedMethodInfo, +#endif + responsePolicyDecisionIsMimeTypeSupported, + + + + + -- * Properties +-- ** request #attr:request# +{- | This property contains the 'GI.WebKit2.Objects.URIRequest.URIRequest' associated with this +policy decision. +-} +#if ENABLE_OVERLOADING + ResponsePolicyDecisionRequestPropertyInfo, +#endif + getResponsePolicyDecisionRequest , +#if ENABLE_OVERLOADING + responsePolicyDecisionRequest , +#endif + + +-- ** response #attr:response# +{- | This property contains the 'GI.WebKit2.Objects.URIResponse.URIResponse' associated with this +policy decision. +-} +#if ENABLE_OVERLOADING + ResponsePolicyDecisionResponsePropertyInfo, +#endif + getResponsePolicyDecisionResponse , +#if ENABLE_OVERLOADING + responsePolicyDecisionResponse , +#endif + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.PolicyDecision as WebKit2.PolicyDecision +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 ResponsePolicyDecision = ResponsePolicyDecision (ManagedPtr ResponsePolicyDecision) +foreign import ccall "webkit_response_policy_decision_get_type" + c_webkit_response_policy_decision_get_type :: IO GType + +instance GObject ResponsePolicyDecision where + gobjectType = c_webkit_response_policy_decision_get_type + + +-- | Type class for types which can be safely cast to `ResponsePolicyDecision`, for instance with `toResponsePolicyDecision`. +class (GObject o, O.IsDescendantOf ResponsePolicyDecision o) => IsResponsePolicyDecision o +instance (GObject o, O.IsDescendantOf ResponsePolicyDecision o) => IsResponsePolicyDecision o + +instance O.HasParentTypes ResponsePolicyDecision +type instance O.ParentTypes ResponsePolicyDecision = '[WebKit2.PolicyDecision.PolicyDecision, GObject.Object.Object] + +-- | Cast to `ResponsePolicyDecision`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toResponsePolicyDecision :: (MonadIO m, IsResponsePolicyDecision o) => o -> m ResponsePolicyDecision +toResponsePolicyDecision = liftIO . unsafeCastTo ResponsePolicyDecision + +-- | A convenience alias for `Nothing` :: `Maybe` `ResponsePolicyDecision`. +noResponsePolicyDecision :: Maybe ResponsePolicyDecision +noResponsePolicyDecision = Nothing + +#if ENABLE_OVERLOADING +type family ResolveResponsePolicyDecisionMethod (t :: Symbol) (o :: *) :: * where + ResolveResponsePolicyDecisionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveResponsePolicyDecisionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveResponsePolicyDecisionMethod "download" o = WebKit2.PolicyDecision.PolicyDecisionDownloadMethodInfo + ResolveResponsePolicyDecisionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveResponsePolicyDecisionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveResponsePolicyDecisionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveResponsePolicyDecisionMethod "ignore" o = WebKit2.PolicyDecision.PolicyDecisionIgnoreMethodInfo + ResolveResponsePolicyDecisionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveResponsePolicyDecisionMethod "isMimeTypeSupported" o = ResponsePolicyDecisionIsMimeTypeSupportedMethodInfo + ResolveResponsePolicyDecisionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveResponsePolicyDecisionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveResponsePolicyDecisionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveResponsePolicyDecisionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveResponsePolicyDecisionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveResponsePolicyDecisionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveResponsePolicyDecisionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveResponsePolicyDecisionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveResponsePolicyDecisionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveResponsePolicyDecisionMethod "use" o = WebKit2.PolicyDecision.PolicyDecisionUseMethodInfo + ResolveResponsePolicyDecisionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveResponsePolicyDecisionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveResponsePolicyDecisionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveResponsePolicyDecisionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveResponsePolicyDecisionMethod "getRequest" o = ResponsePolicyDecisionGetRequestMethodInfo + ResolveResponsePolicyDecisionMethod "getResponse" o = ResponsePolicyDecisionGetResponseMethodInfo + ResolveResponsePolicyDecisionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveResponsePolicyDecisionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveResponsePolicyDecisionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveResponsePolicyDecisionMethod t ResponsePolicyDecision, O.MethodInfo info ResponsePolicyDecision p) => OL.IsLabel t (ResponsePolicyDecision -> 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 + +-- VVV Prop "request" + -- Type: TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@request@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' responsePolicyDecision #request +@ +-} +getResponsePolicyDecisionRequest :: (MonadIO m, IsResponsePolicyDecision o) => o -> m WebKit2.URIRequest.URIRequest +getResponsePolicyDecisionRequest obj = liftIO $ checkUnexpectedNothing "getResponsePolicyDecisionRequest" $ B.Properties.getObjectPropertyObject obj "request" WebKit2.URIRequest.URIRequest + +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionRequestPropertyInfo +instance AttrInfo ResponsePolicyDecisionRequestPropertyInfo where + type AttrAllowedOps ResponsePolicyDecisionRequestPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ResponsePolicyDecisionRequestPropertyInfo = (~) () + type AttrBaseTypeConstraint ResponsePolicyDecisionRequestPropertyInfo = IsResponsePolicyDecision + type AttrGetType ResponsePolicyDecisionRequestPropertyInfo = WebKit2.URIRequest.URIRequest + type AttrLabel ResponsePolicyDecisionRequestPropertyInfo = "request" + type AttrOrigin ResponsePolicyDecisionRequestPropertyInfo = ResponsePolicyDecision + attrGet _ = getResponsePolicyDecisionRequest + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "response" + -- Type: TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@response@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' responsePolicyDecision #response +@ +-} +getResponsePolicyDecisionResponse :: (MonadIO m, IsResponsePolicyDecision o) => o -> m WebKit2.URIResponse.URIResponse +getResponsePolicyDecisionResponse obj = liftIO $ checkUnexpectedNothing "getResponsePolicyDecisionResponse" $ B.Properties.getObjectPropertyObject obj "response" WebKit2.URIResponse.URIResponse + +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionResponsePropertyInfo +instance AttrInfo ResponsePolicyDecisionResponsePropertyInfo where + type AttrAllowedOps ResponsePolicyDecisionResponsePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ResponsePolicyDecisionResponsePropertyInfo = (~) () + type AttrBaseTypeConstraint ResponsePolicyDecisionResponsePropertyInfo = IsResponsePolicyDecision + type AttrGetType ResponsePolicyDecisionResponsePropertyInfo = WebKit2.URIResponse.URIResponse + type AttrLabel ResponsePolicyDecisionResponsePropertyInfo = "response" + type AttrOrigin ResponsePolicyDecisionResponsePropertyInfo = ResponsePolicyDecision + attrGet _ = getResponsePolicyDecisionResponse + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ResponsePolicyDecision +type instance O.AttributeList ResponsePolicyDecision = ResponsePolicyDecisionAttributeList +type ResponsePolicyDecisionAttributeList = ('[ '("request", ResponsePolicyDecisionRequestPropertyInfo), '("response", ResponsePolicyDecisionResponsePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +responsePolicyDecisionRequest :: AttrLabelProxy "request" +responsePolicyDecisionRequest = AttrLabelProxy + +responsePolicyDecisionResponse :: AttrLabelProxy "response" +responsePolicyDecisionResponse = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList ResponsePolicyDecision = ResponsePolicyDecisionSignalList +type ResponsePolicyDecisionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method ResponsePolicyDecision::get_request +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitResponsePolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIRequest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_response_policy_decision_get_request" webkit_response_policy_decision_get_request :: + Ptr ResponsePolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}) + IO (Ptr WebKit2.URIRequest.URIRequest) + +{- | +Return the 'GI.WebKit2.Objects.URIRequest.URIRequest' associated with the response decision. +Modifications to the returned object are \not\<\/emphasis> taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a response decision should be taken or +not. To modify requests before they are sent over the network the +@/WebKitPage::send-request/@ signal can be used instead. +-} +responsePolicyDecisionGetRequest :: + (B.CallStack.HasCallStack, MonadIO m, IsResponsePolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision' -} + -> m WebKit2.URIRequest.URIRequest + {- ^ __Returns:__ The URI request that is associated with this policy decision. -} +responsePolicyDecisionGetRequest decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_response_policy_decision_get_request decision' + checkUnexpectedReturnNULL "responsePolicyDecisionGetRequest" result + result' <- (newObject WebKit2.URIRequest.URIRequest) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionGetRequestMethodInfo +instance (signature ~ (m WebKit2.URIRequest.URIRequest), MonadIO m, IsResponsePolicyDecision a) => O.MethodInfo ResponsePolicyDecisionGetRequestMethodInfo a signature where + overloadedMethod _ = responsePolicyDecisionGetRequest + +#endif + +-- method ResponsePolicyDecision::get_response +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitResponsePolicyDecision", 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_response_policy_decision_get_response" webkit_response_policy_decision_get_response :: + Ptr ResponsePolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}) + IO (Ptr WebKit2.URIResponse.URIResponse) + +{- | +Gets the value of the 'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision':@/response/@ property. +-} +responsePolicyDecisionGetResponse :: + (B.CallStack.HasCallStack, MonadIO m, IsResponsePolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision' -} + -> m WebKit2.URIResponse.URIResponse + {- ^ __Returns:__ The URI response that is associated with this policy decision. -} +responsePolicyDecisionGetResponse decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_response_policy_decision_get_response decision' + checkUnexpectedReturnNULL "responsePolicyDecisionGetResponse" result + result' <- (newObject WebKit2.URIResponse.URIResponse) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionGetResponseMethodInfo +instance (signature ~ (m WebKit2.URIResponse.URIResponse), MonadIO m, IsResponsePolicyDecision a) => O.MethodInfo ResponsePolicyDecisionGetResponseMethodInfo a signature where + overloadedMethod _ = responsePolicyDecisionGetResponse + +#endif + +-- method ResponsePolicyDecision::is_mime_type_supported +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decision", argType = TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitResponsePolicyDecision", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_response_policy_decision_is_mime_type_supported" webkit_response_policy_decision_is_mime_type_supported :: + Ptr ResponsePolicyDecision -> -- decision : TInterface (Name {namespace = "WebKit2", name = "ResponsePolicyDecision"}) + IO CInt + +{- | +Gets whether the MIME type of the response can be displayed in the 'GI.WebKit2.Objects.WebView.WebView' +that triggered this policy decision request. See also 'GI.WebKit2.Objects.WebView.webViewCanShowMimeType'. + +/Since: 2.4/ +-} +responsePolicyDecisionIsMimeTypeSupported :: + (B.CallStack.HasCallStack, MonadIO m, IsResponsePolicyDecision a) => + a + {- ^ /@decision@/: a 'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision' -} + -> m Bool + {- ^ __Returns:__ 'True' if the MIME type of the response is supported or 'False' otherwise -} +responsePolicyDecisionIsMimeTypeSupported decision = liftIO $ do + decision' <- unsafeManagedPtrCastPtr decision + result <- webkit_response_policy_decision_is_mime_type_supported decision' + let result' = (/= 0) result + touchManagedPtr decision + return result' + +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionIsMimeTypeSupportedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsResponsePolicyDecision a) => O.MethodInfo ResponsePolicyDecisionIsMimeTypeSupportedMethodInfo a signature where + overloadedMethod _ = responsePolicyDecisionIsMimeTypeSupported + +#endif + + diff --git a/GI/WebKit2/Objects/ResponsePolicyDecision.hs-boot b/GI/WebKit2/Objects/ResponsePolicyDecision.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/ResponsePolicyDecision.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.ResponsePolicyDecision 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 + +newtype ResponsePolicyDecision = ResponsePolicyDecision (ManagedPtr ResponsePolicyDecision) +instance GObject ResponsePolicyDecision where +class (GObject o, O.IsDescendantOf ResponsePolicyDecision o) => IsResponsePolicyDecision o +instance (GObject o, O.IsDescendantOf ResponsePolicyDecision o) => IsResponsePolicyDecision o +instance O.HasParentTypes ResponsePolicyDecision +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionRequestPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionResponsePropertyInfo +#endif +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionGetRequestMethodInfo +#endif +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionGetResponseMethodInfo +#endif +#if ENABLE_OVERLOADING +data ResponsePolicyDecisionIsMimeTypeSupportedMethodInfo +#endif diff --git a/GI/WebKit2/Objects/SecurityManager.hs b/GI/WebKit2/Objects/SecurityManager.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/SecurityManager.hs @@ -0,0 +1,714 @@ + + +{- | +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.SecurityManager + ( + +-- * Exported types + SecurityManager(..) , + IsSecurityManager , + toSecurityManager , + noSecurityManager , + + + -- * Methods +-- ** registerUriSchemeAsCorsEnabled #method:registerUriSchemeAsCorsEnabled# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsCorsEnabledMethodInfo, +#endif + securityManagerRegisterUriSchemeAsCorsEnabled, + + +-- ** registerUriSchemeAsDisplayIsolated #method:registerUriSchemeAsDisplayIsolated# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsDisplayIsolatedMethodInfo, +#endif + securityManagerRegisterUriSchemeAsDisplayIsolated, + + +-- ** registerUriSchemeAsEmptyDocument #method:registerUriSchemeAsEmptyDocument# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsEmptyDocumentMethodInfo, +#endif + securityManagerRegisterUriSchemeAsEmptyDocument, + + +-- ** registerUriSchemeAsLocal #method:registerUriSchemeAsLocal# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsLocalMethodInfo, +#endif + securityManagerRegisterUriSchemeAsLocal , + + +-- ** registerUriSchemeAsNoAccess #method:registerUriSchemeAsNoAccess# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsNoAccessMethodInfo, +#endif + securityManagerRegisterUriSchemeAsNoAccess, + + +-- ** registerUriSchemeAsSecure #method:registerUriSchemeAsSecure# + +#if ENABLE_OVERLOADING + SecurityManagerRegisterUriSchemeAsSecureMethodInfo, +#endif + securityManagerRegisterUriSchemeAsSecure, + + +-- ** uriSchemeIsCorsEnabled #method:uriSchemeIsCorsEnabled# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsCorsEnabledMethodInfo, +#endif + securityManagerUriSchemeIsCorsEnabled , + + +-- ** uriSchemeIsDisplayIsolated #method:uriSchemeIsDisplayIsolated# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsDisplayIsolatedMethodInfo, +#endif + securityManagerUriSchemeIsDisplayIsolated, + + +-- ** uriSchemeIsEmptyDocument #method:uriSchemeIsEmptyDocument# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsEmptyDocumentMethodInfo, +#endif + securityManagerUriSchemeIsEmptyDocument , + + +-- ** uriSchemeIsLocal #method:uriSchemeIsLocal# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsLocalMethodInfo, +#endif + securityManagerUriSchemeIsLocal , + + +-- ** uriSchemeIsNoAccess #method:uriSchemeIsNoAccess# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsNoAccessMethodInfo, +#endif + securityManagerUriSchemeIsNoAccess , + + +-- ** uriSchemeIsSecure #method:uriSchemeIsSecure# + +#if ENABLE_OVERLOADING + SecurityManagerUriSchemeIsSecureMethodInfo, +#endif + securityManagerUriSchemeIsSecure , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype SecurityManager = SecurityManager (ManagedPtr SecurityManager) +foreign import ccall "webkit_security_manager_get_type" + c_webkit_security_manager_get_type :: IO GType + +instance GObject SecurityManager where + gobjectType = c_webkit_security_manager_get_type + + +-- | Type class for types which can be safely cast to `SecurityManager`, for instance with `toSecurityManager`. +class (GObject o, O.IsDescendantOf SecurityManager o) => IsSecurityManager o +instance (GObject o, O.IsDescendantOf SecurityManager o) => IsSecurityManager o + +instance O.HasParentTypes SecurityManager +type instance O.ParentTypes SecurityManager = '[GObject.Object.Object] + +-- | Cast to `SecurityManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSecurityManager :: (MonadIO m, IsSecurityManager o) => o -> m SecurityManager +toSecurityManager = liftIO . unsafeCastTo SecurityManager + +-- | A convenience alias for `Nothing` :: `Maybe` `SecurityManager`. +noSecurityManager :: Maybe SecurityManager +noSecurityManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSecurityManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveSecurityManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSecurityManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSecurityManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSecurityManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSecurityManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSecurityManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSecurityManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSecurityManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSecurityManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSecurityManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsCorsEnabled" o = SecurityManagerRegisterUriSchemeAsCorsEnabledMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsDisplayIsolated" o = SecurityManagerRegisterUriSchemeAsDisplayIsolatedMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsEmptyDocument" o = SecurityManagerRegisterUriSchemeAsEmptyDocumentMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsLocal" o = SecurityManagerRegisterUriSchemeAsLocalMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsNoAccess" o = SecurityManagerRegisterUriSchemeAsNoAccessMethodInfo + ResolveSecurityManagerMethod "registerUriSchemeAsSecure" o = SecurityManagerRegisterUriSchemeAsSecureMethodInfo + ResolveSecurityManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSecurityManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSecurityManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSecurityManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSecurityManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsCorsEnabled" o = SecurityManagerUriSchemeIsCorsEnabledMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsDisplayIsolated" o = SecurityManagerUriSchemeIsDisplayIsolatedMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsEmptyDocument" o = SecurityManagerUriSchemeIsEmptyDocumentMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsLocal" o = SecurityManagerUriSchemeIsLocalMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsNoAccess" o = SecurityManagerUriSchemeIsNoAccessMethodInfo + ResolveSecurityManagerMethod "uriSchemeIsSecure" o = SecurityManagerUriSchemeIsSecureMethodInfo + ResolveSecurityManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSecurityManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSecurityManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSecurityManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSecurityManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSecurityManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSecurityManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSecurityManagerMethod t SecurityManager, O.MethodInfo info SecurityManager p) => OL.IsLabel t (SecurityManager -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SecurityManager +type instance O.AttributeList SecurityManager = SecurityManagerAttributeList +type SecurityManagerAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SecurityManager = SecurityManagerSignalList +type SecurityManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SecurityManager::register_uri_scheme_as_cors_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_cors_enabled" webkit_security_manager_register_uri_scheme_as_cors_enabled :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as a CORS (Cross-origin resource sharing) enabled scheme. +This means that CORS requests are allowed. See W3C CORS specification +http:\/\/www.w3.org\/TR\/cors\/. +-} +securityManagerRegisterUriSchemeAsCorsEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsCorsEnabled securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_cors_enabled securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsCorsEnabledMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsCorsEnabledMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsCorsEnabled + +#endif + +-- method SecurityManager::register_uri_scheme_as_display_isolated +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_display_isolated" webkit_security_manager_register_uri_scheme_as_display_isolated :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as a display isolated scheme. This means that pages cannot +display these URIs unless they are from the same scheme. +-} +securityManagerRegisterUriSchemeAsDisplayIsolated :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsDisplayIsolated securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_display_isolated securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsDisplayIsolatedMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsDisplayIsolatedMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsDisplayIsolated + +#endif + +-- method SecurityManager::register_uri_scheme_as_empty_document +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_empty_document" webkit_security_manager_register_uri_scheme_as_empty_document :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as an empty document scheme. This means that +they are allowed to commit synchronously. +-} +securityManagerRegisterUriSchemeAsEmptyDocument :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsEmptyDocument securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_empty_document securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsEmptyDocumentMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsEmptyDocumentMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsEmptyDocument + +#endif + +-- method SecurityManager::register_uri_scheme_as_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_local" webkit_security_manager_register_uri_scheme_as_local :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as a local scheme. This means that other non-local pages +cannot link to or access URIs of this scheme. +-} +securityManagerRegisterUriSchemeAsLocal :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsLocal securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_local securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsLocalMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsLocalMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsLocal + +#endif + +-- method SecurityManager::register_uri_scheme_as_no_access +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_no_access" webkit_security_manager_register_uri_scheme_as_no_access :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as a no-access scheme. This means that pages loaded +with this URI scheme cannot access pages loaded with any other URI scheme. +-} +securityManagerRegisterUriSchemeAsNoAccess :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsNoAccess securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_no_access securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsNoAccessMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsNoAccessMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsNoAccess + +#endif + +-- method SecurityManager::register_uri_scheme_as_secure +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_register_uri_scheme_as_secure" webkit_security_manager_register_uri_scheme_as_secure :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO () + +{- | +Register /@scheme@/ as a secure scheme. This means that mixed +content warnings won\'t be generated for this scheme when +included by an HTTPS page. +-} +securityManagerRegisterUriSchemeAsSecure :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m () +securityManagerRegisterUriSchemeAsSecure securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + webkit_security_manager_register_uri_scheme_as_secure securityManager' scheme' + touchManagedPtr securityManager + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsSecureMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerRegisterUriSchemeAsSecureMethodInfo a signature where + overloadedMethod _ = securityManagerRegisterUriSchemeAsSecure + +#endif + +-- method SecurityManager::uri_scheme_is_cors_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_cors_enabled" webkit_security_manager_uri_scheme_is_cors_enabled :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as a CORS enabled scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsCorsEnabled'. +-} +securityManagerUriSchemeIsCorsEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is a CORS enabled scheme or 'False' otherwise. -} +securityManagerUriSchemeIsCorsEnabled securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_cors_enabled securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsCorsEnabledMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsCorsEnabledMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsCorsEnabled + +#endif + +-- method SecurityManager::uri_scheme_is_display_isolated +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_display_isolated" webkit_security_manager_uri_scheme_is_display_isolated :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as a display isolated scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsDisplayIsolated'. +-} +securityManagerUriSchemeIsDisplayIsolated :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is a display isolated scheme or 'False' otherwise. -} +securityManagerUriSchemeIsDisplayIsolated securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_display_isolated securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsDisplayIsolatedMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsDisplayIsolatedMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsDisplayIsolated + +#endif + +-- method SecurityManager::uri_scheme_is_empty_document +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_empty_document" webkit_security_manager_uri_scheme_is_empty_document :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as an empty document scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsEmptyDocument'. +-} +securityManagerUriSchemeIsEmptyDocument :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is an empty document scheme or 'False' otherwise. -} +securityManagerUriSchemeIsEmptyDocument securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_empty_document securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsEmptyDocumentMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsEmptyDocumentMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsEmptyDocument + +#endif + +-- method SecurityManager::uri_scheme_is_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_local" webkit_security_manager_uri_scheme_is_local :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as a local scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsLocal'. +-} +securityManagerUriSchemeIsLocal :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is a local scheme or 'False' otherwise. -} +securityManagerUriSchemeIsLocal securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_local securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsLocalMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsLocalMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsLocal + +#endif + +-- method SecurityManager::uri_scheme_is_no_access +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_no_access" webkit_security_manager_uri_scheme_is_no_access :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as a no-access scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsNoAccess'. +-} +securityManagerUriSchemeIsNoAccess :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is a no-access scheme or 'False' otherwise. -} +securityManagerUriSchemeIsNoAccess securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_no_access securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsNoAccessMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsNoAccessMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsNoAccess + +#endif + +-- method SecurityManager::uri_scheme_is_secure +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "security_manager", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_manager_uri_scheme_is_secure" webkit_security_manager_uri_scheme_is_secure :: + Ptr SecurityManager -> -- security_manager : TInterface (Name {namespace = "WebKit2", name = "SecurityManager"}) + CString -> -- scheme : TBasicType TUTF8 + IO CInt + +{- | +Whether /@scheme@/ is considered as a secure scheme. +See also 'GI.WebKit2.Objects.SecurityManager.securityManagerRegisterUriSchemeAsSecure'. +-} +securityManagerUriSchemeIsSecure :: + (B.CallStack.HasCallStack, MonadIO m, IsSecurityManager a) => + a + {- ^ /@securityManager@/: a 'GI.WebKit2.Objects.SecurityManager.SecurityManager' -} + -> T.Text + {- ^ /@scheme@/: a URI scheme -} + -> m Bool + {- ^ __Returns:__ 'True' if /@scheme@/ is a secure scheme or 'False' otherwise. -} +securityManagerUriSchemeIsSecure securityManager scheme = liftIO $ do + securityManager' <- unsafeManagedPtrCastPtr securityManager + scheme' <- textToCString scheme + result <- webkit_security_manager_uri_scheme_is_secure securityManager' scheme' + let result' = (/= 0) result + touchManagedPtr securityManager + freeMem scheme' + return result' + +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsSecureMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSecurityManager a) => O.MethodInfo SecurityManagerUriSchemeIsSecureMethodInfo a signature where + overloadedMethod _ = securityManagerUriSchemeIsSecure + +#endif + + diff --git a/GI/WebKit2/Objects/SecurityManager.hs-boot b/GI/WebKit2/Objects/SecurityManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/SecurityManager.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.SecurityManager 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 + +newtype SecurityManager = SecurityManager (ManagedPtr SecurityManager) +instance GObject SecurityManager where +class (GObject o, O.IsDescendantOf SecurityManager o) => IsSecurityManager o +instance (GObject o, O.IsDescendantOf SecurityManager o) => IsSecurityManager o +instance O.HasParentTypes SecurityManager +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsCorsEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsDisplayIsolatedMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsEmptyDocumentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsLocalMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsNoAccessMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerRegisterUriSchemeAsSecureMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsCorsEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsDisplayIsolatedMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsEmptyDocumentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsLocalMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsNoAccessMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityManagerUriSchemeIsSecureMethodInfo +#endif diff --git a/GI/WebKit2/Objects/Settings.hs b/GI/WebKit2/Objects/Settings.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Settings.hs @@ -0,0 +1,9222 @@ + + +{- | +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.Settings + ( + +-- * Exported types + Settings(..) , + IsSettings , + toSettings , + noSettings , + + + -- * Methods +-- ** fontSizeToPixels #method:fontSizeToPixels# + + settingsFontSizeToPixels , + + +-- ** fontSizeToPoints #method:fontSizeToPoints# + + settingsFontSizeToPoints , + + +-- ** getAllowFileAccessFromFileUrls #method:getAllowFileAccessFromFileUrls# + +#if ENABLE_OVERLOADING + SettingsGetAllowFileAccessFromFileUrlsMethodInfo, +#endif + settingsGetAllowFileAccessFromFileUrls , + + +-- ** getAllowModalDialogs #method:getAllowModalDialogs# + +#if ENABLE_OVERLOADING + SettingsGetAllowModalDialogsMethodInfo , +#endif + settingsGetAllowModalDialogs , + + +-- ** getAllowUniversalAccessFromFileUrls #method:getAllowUniversalAccessFromFileUrls# + +#if ENABLE_OVERLOADING + SettingsGetAllowUniversalAccessFromFileUrlsMethodInfo, +#endif + settingsGetAllowUniversalAccessFromFileUrls, + + +-- ** getAutoLoadImages #method:getAutoLoadImages# + +#if ENABLE_OVERLOADING + SettingsGetAutoLoadImagesMethodInfo , +#endif + settingsGetAutoLoadImages , + + +-- ** getCursiveFontFamily #method:getCursiveFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetCursiveFontFamilyMethodInfo , +#endif + settingsGetCursiveFontFamily , + + +-- ** getDefaultCharset #method:getDefaultCharset# + +#if ENABLE_OVERLOADING + SettingsGetDefaultCharsetMethodInfo , +#endif + settingsGetDefaultCharset , + + +-- ** getDefaultFontFamily #method:getDefaultFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetDefaultFontFamilyMethodInfo , +#endif + settingsGetDefaultFontFamily , + + +-- ** getDefaultFontSize #method:getDefaultFontSize# + +#if ENABLE_OVERLOADING + SettingsGetDefaultFontSizeMethodInfo , +#endif + settingsGetDefaultFontSize , + + +-- ** getDefaultMonospaceFontSize #method:getDefaultMonospaceFontSize# + +#if ENABLE_OVERLOADING + SettingsGetDefaultMonospaceFontSizeMethodInfo, +#endif + settingsGetDefaultMonospaceFontSize , + + +-- ** getDrawCompositingIndicators #method:getDrawCompositingIndicators# + +#if ENABLE_OVERLOADING + SettingsGetDrawCompositingIndicatorsMethodInfo, +#endif + settingsGetDrawCompositingIndicators , + + +-- ** getEnableAccelerated2dCanvas #method:getEnableAccelerated2dCanvas# + +#if ENABLE_OVERLOADING + SettingsGetEnableAccelerated2dCanvasMethodInfo, +#endif + settingsGetEnableAccelerated2dCanvas , + + +-- ** getEnableBackForwardNavigationGestures #method:getEnableBackForwardNavigationGestures# + +#if ENABLE_OVERLOADING + SettingsGetEnableBackForwardNavigationGesturesMethodInfo, +#endif + settingsGetEnableBackForwardNavigationGestures, + + +-- ** getEnableCaretBrowsing #method:getEnableCaretBrowsing# + +#if ENABLE_OVERLOADING + SettingsGetEnableCaretBrowsingMethodInfo, +#endif + settingsGetEnableCaretBrowsing , + + +-- ** getEnableDeveloperExtras #method:getEnableDeveloperExtras# + +#if ENABLE_OVERLOADING + SettingsGetEnableDeveloperExtrasMethodInfo, +#endif + settingsGetEnableDeveloperExtras , + + +-- ** getEnableDnsPrefetching #method:getEnableDnsPrefetching# + +#if ENABLE_OVERLOADING + SettingsGetEnableDnsPrefetchingMethodInfo, +#endif + settingsGetEnableDnsPrefetching , + + +-- ** getEnableEncryptedMedia #method:getEnableEncryptedMedia# + +#if ENABLE_OVERLOADING + SettingsGetEnableEncryptedMediaMethodInfo, +#endif + settingsGetEnableEncryptedMedia , + + +-- ** getEnableFrameFlattening #method:getEnableFrameFlattening# + +#if ENABLE_OVERLOADING + SettingsGetEnableFrameFlatteningMethodInfo, +#endif + settingsGetEnableFrameFlattening , + + +-- ** getEnableFullscreen #method:getEnableFullscreen# + +#if ENABLE_OVERLOADING + SettingsGetEnableFullscreenMethodInfo , +#endif + settingsGetEnableFullscreen , + + +-- ** getEnableHtml5Database #method:getEnableHtml5Database# + +#if ENABLE_OVERLOADING + SettingsGetEnableHtml5DatabaseMethodInfo, +#endif + settingsGetEnableHtml5Database , + + +-- ** getEnableHtml5LocalStorage #method:getEnableHtml5LocalStorage# + +#if ENABLE_OVERLOADING + SettingsGetEnableHtml5LocalStorageMethodInfo, +#endif + settingsGetEnableHtml5LocalStorage , + + +-- ** getEnableHyperlinkAuditing #method:getEnableHyperlinkAuditing# + +#if ENABLE_OVERLOADING + SettingsGetEnableHyperlinkAuditingMethodInfo, +#endif + settingsGetEnableHyperlinkAuditing , + + +-- ** getEnableJava #method:getEnableJava# + +#if ENABLE_OVERLOADING + SettingsGetEnableJavaMethodInfo , +#endif + settingsGetEnableJava , + + +-- ** getEnableJavascript #method:getEnableJavascript# + +#if ENABLE_OVERLOADING + SettingsGetEnableJavascriptMethodInfo , +#endif + settingsGetEnableJavascript , + + +-- ** getEnableJavascriptMarkup #method:getEnableJavascriptMarkup# + +#if ENABLE_OVERLOADING + SettingsGetEnableJavascriptMarkupMethodInfo, +#endif + settingsGetEnableJavascriptMarkup , + + +-- ** getEnableMediaCapabilities #method:getEnableMediaCapabilities# + +#if ENABLE_OVERLOADING + SettingsGetEnableMediaCapabilitiesMethodInfo, +#endif + settingsGetEnableMediaCapabilities , + + +-- ** getEnableMediaStream #method:getEnableMediaStream# + +#if ENABLE_OVERLOADING + SettingsGetEnableMediaStreamMethodInfo , +#endif + settingsGetEnableMediaStream , + + +-- ** getEnableMediasource #method:getEnableMediasource# + +#if ENABLE_OVERLOADING + SettingsGetEnableMediasourceMethodInfo , +#endif + settingsGetEnableMediasource , + + +-- ** getEnableMockCaptureDevices #method:getEnableMockCaptureDevices# + +#if ENABLE_OVERLOADING + SettingsGetEnableMockCaptureDevicesMethodInfo, +#endif + settingsGetEnableMockCaptureDevices , + + +-- ** getEnableOfflineWebApplicationCache #method:getEnableOfflineWebApplicationCache# + +#if ENABLE_OVERLOADING + SettingsGetEnableOfflineWebApplicationCacheMethodInfo, +#endif + settingsGetEnableOfflineWebApplicationCache, + + +-- ** getEnablePageCache #method:getEnablePageCache# + +#if ENABLE_OVERLOADING + SettingsGetEnablePageCacheMethodInfo , +#endif + settingsGetEnablePageCache , + + +-- ** getEnablePlugins #method:getEnablePlugins# + +#if ENABLE_OVERLOADING + SettingsGetEnablePluginsMethodInfo , +#endif + settingsGetEnablePlugins , + + +-- ** getEnablePrivateBrowsing #method:getEnablePrivateBrowsing# + +#if ENABLE_OVERLOADING + SettingsGetEnablePrivateBrowsingMethodInfo, +#endif + settingsGetEnablePrivateBrowsing , + + +-- ** getEnableResizableTextAreas #method:getEnableResizableTextAreas# + +#if ENABLE_OVERLOADING + SettingsGetEnableResizableTextAreasMethodInfo, +#endif + settingsGetEnableResizableTextAreas , + + +-- ** getEnableSiteSpecificQuirks #method:getEnableSiteSpecificQuirks# + +#if ENABLE_OVERLOADING + SettingsGetEnableSiteSpecificQuirksMethodInfo, +#endif + settingsGetEnableSiteSpecificQuirks , + + +-- ** getEnableSmoothScrolling #method:getEnableSmoothScrolling# + +#if ENABLE_OVERLOADING + SettingsGetEnableSmoothScrollingMethodInfo, +#endif + settingsGetEnableSmoothScrolling , + + +-- ** getEnableSpatialNavigation #method:getEnableSpatialNavigation# + +#if ENABLE_OVERLOADING + SettingsGetEnableSpatialNavigationMethodInfo, +#endif + settingsGetEnableSpatialNavigation , + + +-- ** getEnableTabsToLinks #method:getEnableTabsToLinks# + +#if ENABLE_OVERLOADING + SettingsGetEnableTabsToLinksMethodInfo , +#endif + settingsGetEnableTabsToLinks , + + +-- ** getEnableWebaudio #method:getEnableWebaudio# + +#if ENABLE_OVERLOADING + SettingsGetEnableWebaudioMethodInfo , +#endif + settingsGetEnableWebaudio , + + +-- ** getEnableWebgl #method:getEnableWebgl# + +#if ENABLE_OVERLOADING + SettingsGetEnableWebglMethodInfo , +#endif + settingsGetEnableWebgl , + + +-- ** getEnableWriteConsoleMessagesToStdout #method:getEnableWriteConsoleMessagesToStdout# + +#if ENABLE_OVERLOADING + SettingsGetEnableWriteConsoleMessagesToStdoutMethodInfo, +#endif + settingsGetEnableWriteConsoleMessagesToStdout, + + +-- ** getEnableXssAuditor #method:getEnableXssAuditor# + +#if ENABLE_OVERLOADING + SettingsGetEnableXssAuditorMethodInfo , +#endif + settingsGetEnableXssAuditor , + + +-- ** getFantasyFontFamily #method:getFantasyFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetFantasyFontFamilyMethodInfo , +#endif + settingsGetFantasyFontFamily , + + +-- ** getHardwareAccelerationPolicy #method:getHardwareAccelerationPolicy# + +#if ENABLE_OVERLOADING + SettingsGetHardwareAccelerationPolicyMethodInfo, +#endif + settingsGetHardwareAccelerationPolicy , + + +-- ** getJavascriptCanAccessClipboard #method:getJavascriptCanAccessClipboard# + +#if ENABLE_OVERLOADING + SettingsGetJavascriptCanAccessClipboardMethodInfo, +#endif + settingsGetJavascriptCanAccessClipboard , + + +-- ** getJavascriptCanOpenWindowsAutomatically #method:getJavascriptCanOpenWindowsAutomatically# + +#if ENABLE_OVERLOADING + SettingsGetJavascriptCanOpenWindowsAutomaticallyMethodInfo, +#endif + settingsGetJavascriptCanOpenWindowsAutomatically, + + +-- ** getLoadIconsIgnoringImageLoadSetting #method:getLoadIconsIgnoringImageLoadSetting# + +#if ENABLE_OVERLOADING + SettingsGetLoadIconsIgnoringImageLoadSettingMethodInfo, +#endif + settingsGetLoadIconsIgnoringImageLoadSetting, + + +-- ** getMediaPlaybackAllowsInline #method:getMediaPlaybackAllowsInline# + +#if ENABLE_OVERLOADING + SettingsGetMediaPlaybackAllowsInlineMethodInfo, +#endif + settingsGetMediaPlaybackAllowsInline , + + +-- ** getMediaPlaybackRequiresUserGesture #method:getMediaPlaybackRequiresUserGesture# + +#if ENABLE_OVERLOADING + SettingsGetMediaPlaybackRequiresUserGestureMethodInfo, +#endif + settingsGetMediaPlaybackRequiresUserGesture, + + +-- ** getMinimumFontSize #method:getMinimumFontSize# + +#if ENABLE_OVERLOADING + SettingsGetMinimumFontSizeMethodInfo , +#endif + settingsGetMinimumFontSize , + + +-- ** getMonospaceFontFamily #method:getMonospaceFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetMonospaceFontFamilyMethodInfo, +#endif + settingsGetMonospaceFontFamily , + + +-- ** getPictographFontFamily #method:getPictographFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetPictographFontFamilyMethodInfo, +#endif + settingsGetPictographFontFamily , + + +-- ** getPrintBackgrounds #method:getPrintBackgrounds# + +#if ENABLE_OVERLOADING + SettingsGetPrintBackgroundsMethodInfo , +#endif + settingsGetPrintBackgrounds , + + +-- ** getSansSerifFontFamily #method:getSansSerifFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetSansSerifFontFamilyMethodInfo, +#endif + settingsGetSansSerifFontFamily , + + +-- ** getSerifFontFamily #method:getSerifFontFamily# + +#if ENABLE_OVERLOADING + SettingsGetSerifFontFamilyMethodInfo , +#endif + settingsGetSerifFontFamily , + + +-- ** getUserAgent #method:getUserAgent# + +#if ENABLE_OVERLOADING + SettingsGetUserAgentMethodInfo , +#endif + settingsGetUserAgent , + + +-- ** getZoomTextOnly #method:getZoomTextOnly# + +#if ENABLE_OVERLOADING + SettingsGetZoomTextOnlyMethodInfo , +#endif + settingsGetZoomTextOnly , + + +-- ** new #method:new# + + settingsNew , + + +-- ** setAllowFileAccessFromFileUrls #method:setAllowFileAccessFromFileUrls# + +#if ENABLE_OVERLOADING + SettingsSetAllowFileAccessFromFileUrlsMethodInfo, +#endif + settingsSetAllowFileAccessFromFileUrls , + + +-- ** setAllowModalDialogs #method:setAllowModalDialogs# + +#if ENABLE_OVERLOADING + SettingsSetAllowModalDialogsMethodInfo , +#endif + settingsSetAllowModalDialogs , + + +-- ** setAllowUniversalAccessFromFileUrls #method:setAllowUniversalAccessFromFileUrls# + +#if ENABLE_OVERLOADING + SettingsSetAllowUniversalAccessFromFileUrlsMethodInfo, +#endif + settingsSetAllowUniversalAccessFromFileUrls, + + +-- ** setAutoLoadImages #method:setAutoLoadImages# + +#if ENABLE_OVERLOADING + SettingsSetAutoLoadImagesMethodInfo , +#endif + settingsSetAutoLoadImages , + + +-- ** setCursiveFontFamily #method:setCursiveFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetCursiveFontFamilyMethodInfo , +#endif + settingsSetCursiveFontFamily , + + +-- ** setDefaultCharset #method:setDefaultCharset# + +#if ENABLE_OVERLOADING + SettingsSetDefaultCharsetMethodInfo , +#endif + settingsSetDefaultCharset , + + +-- ** setDefaultFontFamily #method:setDefaultFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetDefaultFontFamilyMethodInfo , +#endif + settingsSetDefaultFontFamily , + + +-- ** setDefaultFontSize #method:setDefaultFontSize# + +#if ENABLE_OVERLOADING + SettingsSetDefaultFontSizeMethodInfo , +#endif + settingsSetDefaultFontSize , + + +-- ** setDefaultMonospaceFontSize #method:setDefaultMonospaceFontSize# + +#if ENABLE_OVERLOADING + SettingsSetDefaultMonospaceFontSizeMethodInfo, +#endif + settingsSetDefaultMonospaceFontSize , + + +-- ** setDrawCompositingIndicators #method:setDrawCompositingIndicators# + +#if ENABLE_OVERLOADING + SettingsSetDrawCompositingIndicatorsMethodInfo, +#endif + settingsSetDrawCompositingIndicators , + + +-- ** setEnableAccelerated2dCanvas #method:setEnableAccelerated2dCanvas# + +#if ENABLE_OVERLOADING + SettingsSetEnableAccelerated2dCanvasMethodInfo, +#endif + settingsSetEnableAccelerated2dCanvas , + + +-- ** setEnableBackForwardNavigationGestures #method:setEnableBackForwardNavigationGestures# + +#if ENABLE_OVERLOADING + SettingsSetEnableBackForwardNavigationGesturesMethodInfo, +#endif + settingsSetEnableBackForwardNavigationGestures, + + +-- ** setEnableCaretBrowsing #method:setEnableCaretBrowsing# + +#if ENABLE_OVERLOADING + SettingsSetEnableCaretBrowsingMethodInfo, +#endif + settingsSetEnableCaretBrowsing , + + +-- ** setEnableDeveloperExtras #method:setEnableDeveloperExtras# + +#if ENABLE_OVERLOADING + SettingsSetEnableDeveloperExtrasMethodInfo, +#endif + settingsSetEnableDeveloperExtras , + + +-- ** setEnableDnsPrefetching #method:setEnableDnsPrefetching# + +#if ENABLE_OVERLOADING + SettingsSetEnableDnsPrefetchingMethodInfo, +#endif + settingsSetEnableDnsPrefetching , + + +-- ** setEnableEncryptedMedia #method:setEnableEncryptedMedia# + +#if ENABLE_OVERLOADING + SettingsSetEnableEncryptedMediaMethodInfo, +#endif + settingsSetEnableEncryptedMedia , + + +-- ** setEnableFrameFlattening #method:setEnableFrameFlattening# + +#if ENABLE_OVERLOADING + SettingsSetEnableFrameFlatteningMethodInfo, +#endif + settingsSetEnableFrameFlattening , + + +-- ** setEnableFullscreen #method:setEnableFullscreen# + +#if ENABLE_OVERLOADING + SettingsSetEnableFullscreenMethodInfo , +#endif + settingsSetEnableFullscreen , + + +-- ** setEnableHtml5Database #method:setEnableHtml5Database# + +#if ENABLE_OVERLOADING + SettingsSetEnableHtml5DatabaseMethodInfo, +#endif + settingsSetEnableHtml5Database , + + +-- ** setEnableHtml5LocalStorage #method:setEnableHtml5LocalStorage# + +#if ENABLE_OVERLOADING + SettingsSetEnableHtml5LocalStorageMethodInfo, +#endif + settingsSetEnableHtml5LocalStorage , + + +-- ** setEnableHyperlinkAuditing #method:setEnableHyperlinkAuditing# + +#if ENABLE_OVERLOADING + SettingsSetEnableHyperlinkAuditingMethodInfo, +#endif + settingsSetEnableHyperlinkAuditing , + + +-- ** setEnableJava #method:setEnableJava# + +#if ENABLE_OVERLOADING + SettingsSetEnableJavaMethodInfo , +#endif + settingsSetEnableJava , + + +-- ** setEnableJavascript #method:setEnableJavascript# + +#if ENABLE_OVERLOADING + SettingsSetEnableJavascriptMethodInfo , +#endif + settingsSetEnableJavascript , + + +-- ** setEnableJavascriptMarkup #method:setEnableJavascriptMarkup# + +#if ENABLE_OVERLOADING + SettingsSetEnableJavascriptMarkupMethodInfo, +#endif + settingsSetEnableJavascriptMarkup , + + +-- ** setEnableMediaCapabilities #method:setEnableMediaCapabilities# + +#if ENABLE_OVERLOADING + SettingsSetEnableMediaCapabilitiesMethodInfo, +#endif + settingsSetEnableMediaCapabilities , + + +-- ** setEnableMediaStream #method:setEnableMediaStream# + +#if ENABLE_OVERLOADING + SettingsSetEnableMediaStreamMethodInfo , +#endif + settingsSetEnableMediaStream , + + +-- ** setEnableMediasource #method:setEnableMediasource# + +#if ENABLE_OVERLOADING + SettingsSetEnableMediasourceMethodInfo , +#endif + settingsSetEnableMediasource , + + +-- ** setEnableMockCaptureDevices #method:setEnableMockCaptureDevices# + +#if ENABLE_OVERLOADING + SettingsSetEnableMockCaptureDevicesMethodInfo, +#endif + settingsSetEnableMockCaptureDevices , + + +-- ** setEnableOfflineWebApplicationCache #method:setEnableOfflineWebApplicationCache# + +#if ENABLE_OVERLOADING + SettingsSetEnableOfflineWebApplicationCacheMethodInfo, +#endif + settingsSetEnableOfflineWebApplicationCache, + + +-- ** setEnablePageCache #method:setEnablePageCache# + +#if ENABLE_OVERLOADING + SettingsSetEnablePageCacheMethodInfo , +#endif + settingsSetEnablePageCache , + + +-- ** setEnablePlugins #method:setEnablePlugins# + +#if ENABLE_OVERLOADING + SettingsSetEnablePluginsMethodInfo , +#endif + settingsSetEnablePlugins , + + +-- ** setEnablePrivateBrowsing #method:setEnablePrivateBrowsing# + +#if ENABLE_OVERLOADING + SettingsSetEnablePrivateBrowsingMethodInfo, +#endif + settingsSetEnablePrivateBrowsing , + + +-- ** setEnableResizableTextAreas #method:setEnableResizableTextAreas# + +#if ENABLE_OVERLOADING + SettingsSetEnableResizableTextAreasMethodInfo, +#endif + settingsSetEnableResizableTextAreas , + + +-- ** setEnableSiteSpecificQuirks #method:setEnableSiteSpecificQuirks# + +#if ENABLE_OVERLOADING + SettingsSetEnableSiteSpecificQuirksMethodInfo, +#endif + settingsSetEnableSiteSpecificQuirks , + + +-- ** setEnableSmoothScrolling #method:setEnableSmoothScrolling# + +#if ENABLE_OVERLOADING + SettingsSetEnableSmoothScrollingMethodInfo, +#endif + settingsSetEnableSmoothScrolling , + + +-- ** setEnableSpatialNavigation #method:setEnableSpatialNavigation# + +#if ENABLE_OVERLOADING + SettingsSetEnableSpatialNavigationMethodInfo, +#endif + settingsSetEnableSpatialNavigation , + + +-- ** setEnableTabsToLinks #method:setEnableTabsToLinks# + +#if ENABLE_OVERLOADING + SettingsSetEnableTabsToLinksMethodInfo , +#endif + settingsSetEnableTabsToLinks , + + +-- ** setEnableWebaudio #method:setEnableWebaudio# + +#if ENABLE_OVERLOADING + SettingsSetEnableWebaudioMethodInfo , +#endif + settingsSetEnableWebaudio , + + +-- ** setEnableWebgl #method:setEnableWebgl# + +#if ENABLE_OVERLOADING + SettingsSetEnableWebglMethodInfo , +#endif + settingsSetEnableWebgl , + + +-- ** setEnableWriteConsoleMessagesToStdout #method:setEnableWriteConsoleMessagesToStdout# + +#if ENABLE_OVERLOADING + SettingsSetEnableWriteConsoleMessagesToStdoutMethodInfo, +#endif + settingsSetEnableWriteConsoleMessagesToStdout, + + +-- ** setEnableXssAuditor #method:setEnableXssAuditor# + +#if ENABLE_OVERLOADING + SettingsSetEnableXssAuditorMethodInfo , +#endif + settingsSetEnableXssAuditor , + + +-- ** setFantasyFontFamily #method:setFantasyFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetFantasyFontFamilyMethodInfo , +#endif + settingsSetFantasyFontFamily , + + +-- ** setHardwareAccelerationPolicy #method:setHardwareAccelerationPolicy# + +#if ENABLE_OVERLOADING + SettingsSetHardwareAccelerationPolicyMethodInfo, +#endif + settingsSetHardwareAccelerationPolicy , + + +-- ** setJavascriptCanAccessClipboard #method:setJavascriptCanAccessClipboard# + +#if ENABLE_OVERLOADING + SettingsSetJavascriptCanAccessClipboardMethodInfo, +#endif + settingsSetJavascriptCanAccessClipboard , + + +-- ** setJavascriptCanOpenWindowsAutomatically #method:setJavascriptCanOpenWindowsAutomatically# + +#if ENABLE_OVERLOADING + SettingsSetJavascriptCanOpenWindowsAutomaticallyMethodInfo, +#endif + settingsSetJavascriptCanOpenWindowsAutomatically, + + +-- ** setLoadIconsIgnoringImageLoadSetting #method:setLoadIconsIgnoringImageLoadSetting# + +#if ENABLE_OVERLOADING + SettingsSetLoadIconsIgnoringImageLoadSettingMethodInfo, +#endif + settingsSetLoadIconsIgnoringImageLoadSetting, + + +-- ** setMediaPlaybackAllowsInline #method:setMediaPlaybackAllowsInline# + +#if ENABLE_OVERLOADING + SettingsSetMediaPlaybackAllowsInlineMethodInfo, +#endif + settingsSetMediaPlaybackAllowsInline , + + +-- ** setMediaPlaybackRequiresUserGesture #method:setMediaPlaybackRequiresUserGesture# + +#if ENABLE_OVERLOADING + SettingsSetMediaPlaybackRequiresUserGestureMethodInfo, +#endif + settingsSetMediaPlaybackRequiresUserGesture, + + +-- ** setMinimumFontSize #method:setMinimumFontSize# + +#if ENABLE_OVERLOADING + SettingsSetMinimumFontSizeMethodInfo , +#endif + settingsSetMinimumFontSize , + + +-- ** setMonospaceFontFamily #method:setMonospaceFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetMonospaceFontFamilyMethodInfo, +#endif + settingsSetMonospaceFontFamily , + + +-- ** setPictographFontFamily #method:setPictographFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetPictographFontFamilyMethodInfo, +#endif + settingsSetPictographFontFamily , + + +-- ** setPrintBackgrounds #method:setPrintBackgrounds# + +#if ENABLE_OVERLOADING + SettingsSetPrintBackgroundsMethodInfo , +#endif + settingsSetPrintBackgrounds , + + +-- ** setSansSerifFontFamily #method:setSansSerifFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetSansSerifFontFamilyMethodInfo, +#endif + settingsSetSansSerifFontFamily , + + +-- ** setSerifFontFamily #method:setSerifFontFamily# + +#if ENABLE_OVERLOADING + SettingsSetSerifFontFamilyMethodInfo , +#endif + settingsSetSerifFontFamily , + + +-- ** setUserAgent #method:setUserAgent# + +#if ENABLE_OVERLOADING + SettingsSetUserAgentMethodInfo , +#endif + settingsSetUserAgent , + + +-- ** setUserAgentWithApplicationDetails #method:setUserAgentWithApplicationDetails# + +#if ENABLE_OVERLOADING + SettingsSetUserAgentWithApplicationDetailsMethodInfo, +#endif + settingsSetUserAgentWithApplicationDetails, + + +-- ** setZoomTextOnly #method:setZoomTextOnly# + +#if ENABLE_OVERLOADING + SettingsSetZoomTextOnlyMethodInfo , +#endif + settingsSetZoomTextOnly , + + + + + -- * Properties +-- ** allowFileAccessFromFileUrls #attr:allowFileAccessFromFileUrls# +{- | Whether file access is allowed from file URLs. By default, when +something is loaded in a 'GI.WebKit2.Objects.WebView.WebView' using a file URI, cross +origin requests to other file resources are not allowed. This +setting allows you to change that behaviour, so that it would be +possible to do a XMLHttpRequest of a local file, for example. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + SettingsAllowFileAccessFromFileUrlsPropertyInfo, +#endif + constructSettingsAllowFileAccessFromFileUrls, + getSettingsAllowFileAccessFromFileUrls , + setSettingsAllowFileAccessFromFileUrls , +#if ENABLE_OVERLOADING + settingsAllowFileAccessFromFileUrls , +#endif + + +-- ** allowModalDialogs #attr:allowModalDialogs# +{- | Determine whether it\'s allowed to create and run modal dialogs +from a 'GI.WebKit2.Objects.WebView.WebView' through JavaScript with +\window.showModalDialog\<\/function>. If it\'s set to +'False', the associated 'GI.WebKit2.Objects.WebView.WebView' won\'t be able to create +new modal dialogs, so not even the 'GI.WebKit2.Objects.WebView.WebView'::@/create/@ +signal will be emitted. +-} +#if ENABLE_OVERLOADING + SettingsAllowModalDialogsPropertyInfo , +#endif + constructSettingsAllowModalDialogs , + getSettingsAllowModalDialogs , + setSettingsAllowModalDialogs , +#if ENABLE_OVERLOADING + settingsAllowModalDialogs , +#endif + + +-- ** allowUniversalAccessFromFileUrls #attr:allowUniversalAccessFromFileUrls# +{- | Whether or not JavaScript running in the context of a file scheme URL +should be allowed to access content from any origin. By default, when +something is loaded in a 'GI.WebKit2.Objects.WebView.WebView' using a file scheme URL, +access to the local file system and arbitrary local storage is not +allowed. This setting allows you to change that behaviour, so that +it would be possible to use local storage, for example. + +/Since: 2.14/ +-} +#if ENABLE_OVERLOADING + SettingsAllowUniversalAccessFromFileUrlsPropertyInfo, +#endif + constructSettingsAllowUniversalAccessFromFileUrls, + getSettingsAllowUniversalAccessFromFileUrls, + setSettingsAllowUniversalAccessFromFileUrls, +#if ENABLE_OVERLOADING + settingsAllowUniversalAccessFromFileUrls, +#endif + + +-- ** autoLoadImages #attr:autoLoadImages# +{- | Determines whether images should be automatically loaded or not. +On devices where network bandwidth is of concern, it might be +useful to turn this property off. +-} +#if ENABLE_OVERLOADING + SettingsAutoLoadImagesPropertyInfo , +#endif + constructSettingsAutoLoadImages , + getSettingsAutoLoadImages , + setSettingsAutoLoadImages , +#if ENABLE_OVERLOADING + settingsAutoLoadImages , +#endif + + +-- ** cursiveFontFamily #attr:cursiveFontFamily# +{- | The font family used as the default for content using a cursive font. +-} +#if ENABLE_OVERLOADING + SettingsCursiveFontFamilyPropertyInfo , +#endif + constructSettingsCursiveFontFamily , + getSettingsCursiveFontFamily , + setSettingsCursiveFontFamily , +#if ENABLE_OVERLOADING + settingsCursiveFontFamily , +#endif + + +-- ** defaultCharset #attr:defaultCharset# +{- | The default text charset used when interpreting content with an unspecified charset. +-} +#if ENABLE_OVERLOADING + SettingsDefaultCharsetPropertyInfo , +#endif + constructSettingsDefaultCharset , + getSettingsDefaultCharset , + setSettingsDefaultCharset , +#if ENABLE_OVERLOADING + settingsDefaultCharset , +#endif + + +-- ** defaultFontFamily #attr:defaultFontFamily# +{- | The font family to use as the default for content that does not specify a font. +-} +#if ENABLE_OVERLOADING + SettingsDefaultFontFamilyPropertyInfo , +#endif + constructSettingsDefaultFontFamily , + getSettingsDefaultFontFamily , + setSettingsDefaultFontFamily , +#if ENABLE_OVERLOADING + settingsDefaultFontFamily , +#endif + + +-- ** defaultFontSize #attr:defaultFontSize# +{- | The default font size in pixels to use for content displayed if +no font size is specified. +-} +#if ENABLE_OVERLOADING + SettingsDefaultFontSizePropertyInfo , +#endif + constructSettingsDefaultFontSize , + getSettingsDefaultFontSize , + setSettingsDefaultFontSize , +#if ENABLE_OVERLOADING + settingsDefaultFontSize , +#endif + + +-- ** defaultMonospaceFontSize #attr:defaultMonospaceFontSize# +{- | The default font size in pixels to use for content displayed in +monospace font if no font size is specified. +-} +#if ENABLE_OVERLOADING + SettingsDefaultMonospaceFontSizePropertyInfo, +#endif + constructSettingsDefaultMonospaceFontSize, + getSettingsDefaultMonospaceFontSize , + setSettingsDefaultMonospaceFontSize , +#if ENABLE_OVERLOADING + settingsDefaultMonospaceFontSize , +#endif + + +-- ** drawCompositingIndicators #attr:drawCompositingIndicators# +{- | Whether to draw compositing borders and repaint counters on layers drawn +with accelerated compositing. This is useful for debugging issues related +to web content that is composited with the GPU. +-} +#if ENABLE_OVERLOADING + SettingsDrawCompositingIndicatorsPropertyInfo, +#endif + constructSettingsDrawCompositingIndicators, + getSettingsDrawCompositingIndicators , + setSettingsDrawCompositingIndicators , +#if ENABLE_OVERLOADING + settingsDrawCompositingIndicators , +#endif + + +-- ** enableAccelerated2dCanvas #attr:enableAccelerated2dCanvas# +{- | Enable or disable accelerated 2D canvas. Accelerated 2D canvas is only available +if WebKit was compiled with a version of Cairo including the unstable CairoGL API. +When accelerated 2D canvas is enabled, WebKit may render some 2D canvas content +using hardware accelerated drawing operations. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + SettingsEnableAccelerated2dCanvasPropertyInfo, +#endif + constructSettingsEnableAccelerated2dCanvas, + getSettingsEnableAccelerated2dCanvas , + setSettingsEnableAccelerated2dCanvas , +#if ENABLE_OVERLOADING + settingsEnableAccelerated2dCanvas , +#endif + + +-- ** enableBackForwardNavigationGestures #attr:enableBackForwardNavigationGestures# +{- | Enable or disable horizontal swipe gesture for back-forward navigation. + +/Since: 2.24/ +-} +#if ENABLE_OVERLOADING + SettingsEnableBackForwardNavigationGesturesPropertyInfo, +#endif + constructSettingsEnableBackForwardNavigationGestures, + getSettingsEnableBackForwardNavigationGestures, + setSettingsEnableBackForwardNavigationGestures, +#if ENABLE_OVERLOADING + settingsEnableBackForwardNavigationGestures, +#endif + + +-- ** enableCaretBrowsing #attr:enableCaretBrowsing# +{- | Whether to enable accessibility enhanced keyboard navigation. +-} +#if ENABLE_OVERLOADING + SettingsEnableCaretBrowsingPropertyInfo , +#endif + constructSettingsEnableCaretBrowsing , + getSettingsEnableCaretBrowsing , + setSettingsEnableCaretBrowsing , +#if ENABLE_OVERLOADING + settingsEnableCaretBrowsing , +#endif + + +-- ** enableDeveloperExtras #attr:enableDeveloperExtras# +{- | Determines whether or not developer tools, such as the Web Inspector, are enabled. +-} +#if ENABLE_OVERLOADING + SettingsEnableDeveloperExtrasPropertyInfo, +#endif + constructSettingsEnableDeveloperExtras , + getSettingsEnableDeveloperExtras , + setSettingsEnableDeveloperExtras , +#if ENABLE_OVERLOADING + settingsEnableDeveloperExtras , +#endif + + +-- ** enableDnsPrefetching #attr:enableDnsPrefetching# +{- | Determines whether or not to prefetch domain names. DNS prefetching attempts +to resolve domain names before a user tries to follow a link. +-} +#if ENABLE_OVERLOADING + SettingsEnableDnsPrefetchingPropertyInfo, +#endif + constructSettingsEnableDnsPrefetching , + getSettingsEnableDnsPrefetching , + setSettingsEnableDnsPrefetching , +#if ENABLE_OVERLOADING + settingsEnableDnsPrefetching , +#endif + + +-- ** enableEncryptedMedia #attr:enableEncryptedMedia# +{- | Enable or disable support for Encrypted Media API on pages. +EncryptedMedia is an experimental JavaScript API for playing encrypted media in HTML. +This property will only work as intended if the EncryptedMedia feature is enabled at build time +with the ENABLE_ENCRYPTED_MEDIA flag. + +See https:\/\/www.w3.org\/TR\/encrypted-media\/ + +/Since: 2.20/ +-} +#if ENABLE_OVERLOADING + SettingsEnableEncryptedMediaPropertyInfo, +#endif + constructSettingsEnableEncryptedMedia , + getSettingsEnableEncryptedMedia , + setSettingsEnableEncryptedMedia , +#if ENABLE_OVERLOADING + settingsEnableEncryptedMedia , +#endif + + +-- ** enableFrameFlattening #attr:enableFrameFlattening# +{- | Whether to enable the frame flattening. With this setting each subframe is expanded +to its contents, which will flatten all the frames to become one scrollable page. +On touch devices scrollable subframes on a page can result in a confusing user experience. +-} +#if ENABLE_OVERLOADING + SettingsEnableFrameFlatteningPropertyInfo, +#endif + constructSettingsEnableFrameFlattening , + getSettingsEnableFrameFlattening , + setSettingsEnableFrameFlattening , +#if ENABLE_OVERLOADING + settingsEnableFrameFlattening , +#endif + + +-- ** enableFullscreen #attr:enableFullscreen# +{- | Whether to enable the Javascript Fullscreen API. The API +allows any HTML element to request fullscreen display. See also +the current draft of the spec: +http:\/\/www.w3.org\/TR\/fullscreen\/ +-} +#if ENABLE_OVERLOADING + SettingsEnableFullscreenPropertyInfo , +#endif + constructSettingsEnableFullscreen , + getSettingsEnableFullscreen , + setSettingsEnableFullscreen , +#if ENABLE_OVERLOADING + settingsEnableFullscreen , +#endif + + +-- ** enableHtml5Database #attr:enableHtml5Database# +{- | Whether to enable HTML5 client-side SQL database support. Client-side +SQL database allows web pages to store structured data and be able to +use SQL to manipulate that data asynchronously. + +HTML5 database specification is available at +http:\/\/www.w3.org\/TR\/webdatabase\/. +-} +#if ENABLE_OVERLOADING + SettingsEnableHtml5DatabasePropertyInfo , +#endif + constructSettingsEnableHtml5Database , + getSettingsEnableHtml5Database , + setSettingsEnableHtml5Database , +#if ENABLE_OVERLOADING + settingsEnableHtml5Database , +#endif + + +-- ** enableHtml5LocalStorage #attr:enableHtml5LocalStorage# +{- | Whether to enable HTML5 local storage support. Local storage provides +simple synchronous storage access. + +HTML5 local storage specification is available at +http:\/\/dev.w3.org\/html5\/webstorage\/. +-} +#if ENABLE_OVERLOADING + SettingsEnableHtml5LocalStoragePropertyInfo, +#endif + constructSettingsEnableHtml5LocalStorage, + getSettingsEnableHtml5LocalStorage , + setSettingsEnableHtml5LocalStorage , +#if ENABLE_OVERLOADING + settingsEnableHtml5LocalStorage , +#endif + + +-- ** enableHyperlinkAuditing #attr:enableHyperlinkAuditing# +{- | Determines whether or not hyperlink auditing is enabled. + +The hyperlink auditing specification is available at +http:\/\/www.whatwg.org\/specs\/web-apps\/current-work\/multipage\/links.html@/hyperlink/@-auditing. +-} +#if ENABLE_OVERLOADING + SettingsEnableHyperlinkAuditingPropertyInfo, +#endif + constructSettingsEnableHyperlinkAuditing, + getSettingsEnableHyperlinkAuditing , + setSettingsEnableHyperlinkAuditing , +#if ENABLE_OVERLOADING + settingsEnableHyperlinkAuditing , +#endif + + +-- ** enableJava #attr:enableJava# +{- | Determines whether or not Java is enabled on the page. +-} +#if ENABLE_OVERLOADING + SettingsEnableJavaPropertyInfo , +#endif + constructSettingsEnableJava , + getSettingsEnableJava , + setSettingsEnableJava , +#if ENABLE_OVERLOADING + settingsEnableJava , +#endif + + +-- ** enableJavascript #attr:enableJavascript# +{- | Determines whether or not JavaScript executes within a page. +-} +#if ENABLE_OVERLOADING + SettingsEnableJavascriptPropertyInfo , +#endif + constructSettingsEnableJavascript , + getSettingsEnableJavascript , + setSettingsEnableJavascript , +#if ENABLE_OVERLOADING + settingsEnableJavascript , +#endif + + +-- ** enableJavascriptMarkup #attr:enableJavascriptMarkup# +{- | Determines whether or not JavaScript markup is allowed in document. When this setting is disabled, +all JavaScript-related elements and attributes are removed from the document during parsing. Note that +executing JavaScript is still allowed if 'GI.WebKit2.Objects.Settings.Settings':@/enable-javascript/@ is 'True'. + +/Since: 2.24/ +-} +#if ENABLE_OVERLOADING + SettingsEnableJavascriptMarkupPropertyInfo, +#endif + constructSettingsEnableJavascriptMarkup , + getSettingsEnableJavascriptMarkup , + setSettingsEnableJavascriptMarkup , +#if ENABLE_OVERLOADING + settingsEnableJavascriptMarkup , +#endif + + +-- ** enableMediaCapabilities #attr:enableMediaCapabilities# +{- | Enable or disable support for MediaCapabilities on pages. This +specification intends to provide APIs to allow websites to make an optimal +decision when picking media content for the user. The APIs will expose +information about the decoding and encoding capabilities for a given format +but also output capabilities to find the best match based on the device’s +display. + +See also https:\/\/wicg.github.io\/media-capabilities\/ + +/Since: 2.22/ +-} +#if ENABLE_OVERLOADING + SettingsEnableMediaCapabilitiesPropertyInfo, +#endif + constructSettingsEnableMediaCapabilities, + getSettingsEnableMediaCapabilities , + setSettingsEnableMediaCapabilities , +#if ENABLE_OVERLOADING + settingsEnableMediaCapabilities , +#endif + + +-- ** enableMediaStream #attr:enableMediaStream# +{- | Enable or disable support for MediaStream on pages. MediaStream +is an experimental proposal for allowing web pages to access +audio and video devices for capture. + +See also http:\/\/dev.w3.org\/2011\/webrtc\/editor\/getusermedia.html + +/Since: 2.4/ +-} +#if ENABLE_OVERLOADING + SettingsEnableMediaStreamPropertyInfo , +#endif + constructSettingsEnableMediaStream , + getSettingsEnableMediaStream , + setSettingsEnableMediaStream , +#if ENABLE_OVERLOADING + settingsEnableMediaStream , +#endif + + +-- ** enableMediasource #attr:enableMediasource# +{- | Enable or disable support for MediaSource on pages. MediaSource +extends HTMLMediaElement to allow JavaScript to generate media +streams for playback. + +See also http:\/\/www.w3.org\/TR\/media-source\/ + +/Since: 2.4/ +-} +#if ENABLE_OVERLOADING + SettingsEnableMediasourcePropertyInfo , +#endif + constructSettingsEnableMediasource , + getSettingsEnableMediasource , + setSettingsEnableMediasource , +#if ENABLE_OVERLOADING + settingsEnableMediasource , +#endif + + +-- ** enableMockCaptureDevices #attr:enableMockCaptureDevices# +{- | Enable or disable the Mock Capture Devices. Those are fake +Microphone and Camera devices to be used as MediaStream +sources. + +/Since: 2.24/ +-} +#if ENABLE_OVERLOADING + SettingsEnableMockCaptureDevicesPropertyInfo, +#endif + constructSettingsEnableMockCaptureDevices, + getSettingsEnableMockCaptureDevices , + setSettingsEnableMockCaptureDevices , +#if ENABLE_OVERLOADING + settingsEnableMockCaptureDevices , +#endif + + +-- ** enableOfflineWebApplicationCache #attr:enableOfflineWebApplicationCache# +{- | Whether to enable HTML5 offline web application cache support. Offline +web application cache allows web applications to run even when +the user is not connected to the network. + +HTML5 offline web application specification is available at +http:\/\/dev.w3.org\/html5\/spec\/offline.html. +-} +#if ENABLE_OVERLOADING + SettingsEnableOfflineWebApplicationCachePropertyInfo, +#endif + constructSettingsEnableOfflineWebApplicationCache, + getSettingsEnableOfflineWebApplicationCache, + setSettingsEnableOfflineWebApplicationCache, +#if ENABLE_OVERLOADING + settingsEnableOfflineWebApplicationCache, +#endif + + +-- ** enablePageCache #attr:enablePageCache# +{- | Enable or disable the page cache. Disabling the page cache is +generally only useful for special circumstances like low-memory +scenarios or special purpose applications like static HTML +viewers. This setting only controls the Page Cache, this cache +is different than the disk-based or memory-based traditional +resource caches, its point is to make going back and forth +between pages much faster. For details about the different types +of caches and their purposes see: +http:\/\/webkit.org\/blog\/427\/webkit-page-cache-i-the-basics\/ +-} +#if ENABLE_OVERLOADING + SettingsEnablePageCachePropertyInfo , +#endif + constructSettingsEnablePageCache , + getSettingsEnablePageCache , + setSettingsEnablePageCache , +#if ENABLE_OVERLOADING + settingsEnablePageCache , +#endif + + +-- ** enablePlugins #attr:enablePlugins# +{- | Determines whether or not plugins on the page are enabled. +-} +#if ENABLE_OVERLOADING + SettingsEnablePluginsPropertyInfo , +#endif + constructSettingsEnablePlugins , + getSettingsEnablePlugins , + setSettingsEnablePlugins , +#if ENABLE_OVERLOADING + settingsEnablePlugins , +#endif + + +-- ** enablePrivateBrowsing #attr:enablePrivateBrowsing# +{- | Determines whether or not private browsing is enabled. Private browsing +will disable history, cache and form auto-fill for any pages visited. +-} +#if ENABLE_OVERLOADING + SettingsEnablePrivateBrowsingPropertyInfo, +#endif + constructSettingsEnablePrivateBrowsing , + getSettingsEnablePrivateBrowsing , + setSettingsEnablePrivateBrowsing , +#if ENABLE_OVERLOADING + settingsEnablePrivateBrowsing , +#endif + + +-- ** enableResizableTextAreas #attr:enableResizableTextAreas# +{- | Determines whether or not text areas can be resized. +-} +#if ENABLE_OVERLOADING + SettingsEnableResizableTextAreasPropertyInfo, +#endif + constructSettingsEnableResizableTextAreas, + getSettingsEnableResizableTextAreas , + setSettingsEnableResizableTextAreas , +#if ENABLE_OVERLOADING + settingsEnableResizableTextAreas , +#endif + + +-- ** enableSiteSpecificQuirks #attr:enableSiteSpecificQuirks# +{- | Whether to turn on site-specific quirks. Turning this on will +tell WebKit to use some site-specific workarounds for +better web compatibility. For example, older versions of +MediaWiki will incorrectly send to WebKit a CSS file with KHTML +workarounds. By turning on site-specific quirks, WebKit will +special-case this and other cases to make some specific sites work. +-} +#if ENABLE_OVERLOADING + SettingsEnableSiteSpecificQuirksPropertyInfo, +#endif + constructSettingsEnableSiteSpecificQuirks, + getSettingsEnableSiteSpecificQuirks , + setSettingsEnableSiteSpecificQuirks , +#if ENABLE_OVERLOADING + settingsEnableSiteSpecificQuirks , +#endif + + +-- ** enableSmoothScrolling #attr:enableSmoothScrolling# +{- | Enable or disable smooth scrolling. +-} +#if ENABLE_OVERLOADING + SettingsEnableSmoothScrollingPropertyInfo, +#endif + constructSettingsEnableSmoothScrolling , + getSettingsEnableSmoothScrolling , + setSettingsEnableSmoothScrolling , +#if ENABLE_OVERLOADING + settingsEnableSmoothScrolling , +#endif + + +-- ** enableSpatialNavigation #attr:enableSpatialNavigation# +{- | Whether to enable Spatial Navigation. This feature consists in the ability +to navigate between focusable elements in a Web page, such as hyperlinks +and form controls, by using Left, Right, Up and Down arrow keys. +For example, if an user presses the Right key, heuristics determine whether +there is an element they might be trying to reach towards the right, and if +there are multiple elements, which element they probably wants. + +/Since: 2.4/ +-} +#if ENABLE_OVERLOADING + SettingsEnableSpatialNavigationPropertyInfo, +#endif + constructSettingsEnableSpatialNavigation, + getSettingsEnableSpatialNavigation , + setSettingsEnableSpatialNavigation , +#if ENABLE_OVERLOADING + settingsEnableSpatialNavigation , +#endif + + +-- ** enableTabsToLinks #attr:enableTabsToLinks# +{- | Determines whether the tab key cycles through the elements on the page. +When this setting is enabled, users will be able to focus the next element +in the page by pressing the tab key. If the selected element is editable, +then pressing tab key will insert the tab character. +-} +#if ENABLE_OVERLOADING + SettingsEnableTabsToLinksPropertyInfo , +#endif + constructSettingsEnableTabsToLinks , + getSettingsEnableTabsToLinks , + setSettingsEnableTabsToLinks , +#if ENABLE_OVERLOADING + settingsEnableTabsToLinks , +#endif + + +-- ** enableWebaudio #attr:enableWebaudio# +{- | Enable or disable support for WebAudio on pages. WebAudio is an +experimental proposal for allowing web pages to generate Audio +WAVE data from JavaScript. The standard is currently a +work-in-progress by the W3C Audio Working Group. + +See also https:\/\/dvcs.w3.org\/hg\/audio\/raw-file\/tip\/webaudio\/specification.html +-} +#if ENABLE_OVERLOADING + SettingsEnableWebaudioPropertyInfo , +#endif + constructSettingsEnableWebaudio , + getSettingsEnableWebaudio , + setSettingsEnableWebaudio , +#if ENABLE_OVERLOADING + settingsEnableWebaudio , +#endif + + +-- ** enableWebgl #attr:enableWebgl# +{- | Enable or disable support for WebGL on pages. WebGL is an experimental +proposal for allowing web pages to use OpenGL ES-like calls directly. The +standard is currently a work-in-progress by the Khronos Group. +-} +#if ENABLE_OVERLOADING + SettingsEnableWebglPropertyInfo , +#endif + constructSettingsEnableWebgl , + getSettingsEnableWebgl , + setSettingsEnableWebgl , +#if ENABLE_OVERLOADING + settingsEnableWebgl , +#endif + + +-- ** enableWriteConsoleMessagesToStdout #attr:enableWriteConsoleMessagesToStdout# +{- | Enable or disable writing console messages to stdout. These are messages +sent to the console with console.log and related methods. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo, +#endif + constructSettingsEnableWriteConsoleMessagesToStdout, + getSettingsEnableWriteConsoleMessagesToStdout, + setSettingsEnableWriteConsoleMessagesToStdout, +#if ENABLE_OVERLOADING + settingsEnableWriteConsoleMessagesToStdout, +#endif + + +-- ** enableXssAuditor #attr:enableXssAuditor# +{- | Whether to enable the XSS auditor. This feature filters some kinds of +reflective XSS attacks on vulnerable web sites. +-} +#if ENABLE_OVERLOADING + SettingsEnableXssAuditorPropertyInfo , +#endif + constructSettingsEnableXssAuditor , + getSettingsEnableXssAuditor , + setSettingsEnableXssAuditor , +#if ENABLE_OVERLOADING + settingsEnableXssAuditor , +#endif + + +-- ** fantasyFontFamily #attr:fantasyFontFamily# +{- | The font family used as the default for content using a fantasy font. +-} +#if ENABLE_OVERLOADING + SettingsFantasyFontFamilyPropertyInfo , +#endif + constructSettingsFantasyFontFamily , + getSettingsFantasyFontFamily , + setSettingsFantasyFontFamily , +#if ENABLE_OVERLOADING + settingsFantasyFontFamily , +#endif + + +-- ** hardwareAccelerationPolicy #attr:hardwareAccelerationPolicy# +{- | The 'GI.WebKit2.Enums.HardwareAccelerationPolicy' to decide how to enable and disable +hardware acceleration. The default value 'GI.WebKit2.Enums.HardwareAccelerationPolicyOnDemand' +enables the hardware acceleration when the web contents request it, disabling it again +when no longer needed. It\'s possible to enforce hardware acceleration to be always enabled +by using 'GI.WebKit2.Enums.HardwareAccelerationPolicyAlways'. And it\'s also possible to disable it +completely using 'GI.WebKit2.Enums.HardwareAccelerationPolicyNever'. Note that disabling hardware +acceleration might cause some websites to not render correctly or consume more CPU. + +Note that changing this setting might not be possible if hardware acceleration is not +supported by the hardware or the system. In that case you can get the value to know the +actual policy being used, but changing the setting will not have any effect. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + SettingsHardwareAccelerationPolicyPropertyInfo, +#endif + constructSettingsHardwareAccelerationPolicy, + getSettingsHardwareAccelerationPolicy , + setSettingsHardwareAccelerationPolicy , +#if ENABLE_OVERLOADING + settingsHardwareAccelerationPolicy , +#endif + + +-- ** javascriptCanAccessClipboard #attr:javascriptCanAccessClipboard# +{- | Whether JavaScript can access the clipboard. The default value is 'False'. If +set to 'True', document.@/execCommand()/@ allows cut, copy and paste commands. +-} +#if ENABLE_OVERLOADING + SettingsJavascriptCanAccessClipboardPropertyInfo, +#endif + constructSettingsJavascriptCanAccessClipboard, + getSettingsJavascriptCanAccessClipboard , + setSettingsJavascriptCanAccessClipboard , +#if ENABLE_OVERLOADING + settingsJavascriptCanAccessClipboard , +#endif + + +-- ** javascriptCanOpenWindowsAutomatically #attr:javascriptCanOpenWindowsAutomatically# +{- | Whether JavaScript can open popup windows automatically without user +intervention. +-} +#if ENABLE_OVERLOADING + SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo, +#endif + constructSettingsJavascriptCanOpenWindowsAutomatically, + getSettingsJavascriptCanOpenWindowsAutomatically, + setSettingsJavascriptCanOpenWindowsAutomatically, +#if ENABLE_OVERLOADING + settingsJavascriptCanOpenWindowsAutomatically, +#endif + + +-- ** loadIconsIgnoringImageLoadSetting #attr:loadIconsIgnoringImageLoadSetting# +{- | Determines whether a site can load favicons irrespective +of the value of 'GI.WebKit2.Objects.Settings.Settings':@/auto-load-images/@. +-} +#if ENABLE_OVERLOADING + SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo, +#endif + constructSettingsLoadIconsIgnoringImageLoadSetting, + getSettingsLoadIconsIgnoringImageLoadSetting, + setSettingsLoadIconsIgnoringImageLoadSetting, +#if ENABLE_OVERLOADING + settingsLoadIconsIgnoringImageLoadSetting, +#endif + + +-- ** mediaPlaybackAllowsInline #attr:mediaPlaybackAllowsInline# +{- | Whether media playback is full-screen only or inline playback is allowed. +This is 'True' by default, so media playback can be inline. Setting it to +'False' allows specifying that media playback should be always fullscreen. +-} +#if ENABLE_OVERLOADING + SettingsMediaPlaybackAllowsInlinePropertyInfo, +#endif + constructSettingsMediaPlaybackAllowsInline, + getSettingsMediaPlaybackAllowsInline , + setSettingsMediaPlaybackAllowsInline , +#if ENABLE_OVERLOADING + settingsMediaPlaybackAllowsInline , +#endif + + +-- ** mediaPlaybackRequiresUserGesture #attr:mediaPlaybackRequiresUserGesture# +{- | Whether a user gesture (such as clicking the play button) +would be required to start media playback or load media. This is off +by default, so media playback could start automatically. +Setting it on requires a gesture by the user to start playback, or to +load the media. +-} +#if ENABLE_OVERLOADING + SettingsMediaPlaybackRequiresUserGesturePropertyInfo, +#endif + constructSettingsMediaPlaybackRequiresUserGesture, + getSettingsMediaPlaybackRequiresUserGesture, + setSettingsMediaPlaybackRequiresUserGesture, +#if ENABLE_OVERLOADING + settingsMediaPlaybackRequiresUserGesture, +#endif + + +-- ** minimumFontSize #attr:minimumFontSize# +{- | The minimum font size in pixels used to display text. This setting +controls the absolute smallest size. Values other than 0 can +potentially break page layouts. +-} +#if ENABLE_OVERLOADING + SettingsMinimumFontSizePropertyInfo , +#endif + constructSettingsMinimumFontSize , + getSettingsMinimumFontSize , + setSettingsMinimumFontSize , +#if ENABLE_OVERLOADING + settingsMinimumFontSize , +#endif + + +-- ** monospaceFontFamily #attr:monospaceFontFamily# +{- | The font family used as the default for content using a monospace font. +-} +#if ENABLE_OVERLOADING + SettingsMonospaceFontFamilyPropertyInfo , +#endif + constructSettingsMonospaceFontFamily , + getSettingsMonospaceFontFamily , + setSettingsMonospaceFontFamily , +#if ENABLE_OVERLOADING + settingsMonospaceFontFamily , +#endif + + +-- ** pictographFontFamily #attr:pictographFontFamily# +{- | The font family used as the default for content using a pictograph font. +-} +#if ENABLE_OVERLOADING + SettingsPictographFontFamilyPropertyInfo, +#endif + constructSettingsPictographFontFamily , + getSettingsPictographFontFamily , + setSettingsPictographFontFamily , +#if ENABLE_OVERLOADING + settingsPictographFontFamily , +#endif + + +-- ** printBackgrounds #attr:printBackgrounds# +{- | Whether background images should be drawn during printing. +-} +#if ENABLE_OVERLOADING + SettingsPrintBackgroundsPropertyInfo , +#endif + constructSettingsPrintBackgrounds , + getSettingsPrintBackgrounds , + setSettingsPrintBackgrounds , +#if ENABLE_OVERLOADING + settingsPrintBackgrounds , +#endif + + +-- ** sansSerifFontFamily #attr:sansSerifFontFamily# +{- | The font family used as the default for content using a sans-serif font. +-} +#if ENABLE_OVERLOADING + SettingsSansSerifFontFamilyPropertyInfo , +#endif + constructSettingsSansSerifFontFamily , + getSettingsSansSerifFontFamily , + setSettingsSansSerifFontFamily , +#if ENABLE_OVERLOADING + settingsSansSerifFontFamily , +#endif + + +-- ** serifFontFamily #attr:serifFontFamily# +{- | The font family used as the default for content using a serif font. +-} +#if ENABLE_OVERLOADING + SettingsSerifFontFamilyPropertyInfo , +#endif + constructSettingsSerifFontFamily , + getSettingsSerifFontFamily , + setSettingsSerifFontFamily , +#if ENABLE_OVERLOADING + settingsSerifFontFamily , +#endif + + +-- ** userAgent #attr:userAgent# +{- | The user-agent string used by WebKit. Unusual user-agent strings may cause web +content to render incorrectly or fail to run, as many web pages are written to +parse the user-agent strings of only the most popular browsers. Therefore, it\'s +typically better to not completely override the standard user-agent, but to use +'GI.WebKit2.Objects.Settings.settingsSetUserAgentWithApplicationDetails' instead. + +If this property is set to the empty string or 'Nothing', it will revert to the standard +user-agent. +-} +#if ENABLE_OVERLOADING + SettingsUserAgentPropertyInfo , +#endif + clearSettingsUserAgent , + constructSettingsUserAgent , + getSettingsUserAgent , + setSettingsUserAgent , +#if ENABLE_OVERLOADING + settingsUserAgent , +#endif + + +-- ** zoomTextOnly #attr:zoomTextOnly# +{- | Whether 'GI.WebKit2.Objects.WebView.WebView':@/zoom-level/@ affects only the +text of the page or all the contents. Other contents containing text +like form controls will be also affected by zoom factor when +this property is enabled. +-} +#if ENABLE_OVERLOADING + SettingsZoomTextOnlyPropertyInfo , +#endif + constructSettingsZoomTextOnly , + getSettingsZoomTextOnly , + setSettingsZoomTextOnly , +#if ENABLE_OVERLOADING + settingsZoomTextOnly , +#endif + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype Settings = Settings (ManagedPtr Settings) +foreign import ccall "webkit_settings_get_type" + c_webkit_settings_get_type :: IO GType + +instance GObject Settings where + gobjectType = c_webkit_settings_get_type + + +-- | Type class for types which can be safely cast to `Settings`, for instance with `toSettings`. +class (GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance (GObject o, O.IsDescendantOf Settings o) => IsSettings o + +instance O.HasParentTypes Settings +type instance O.ParentTypes Settings = '[GObject.Object.Object] + +-- | Cast to `Settings`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSettings :: (MonadIO m, IsSettings o) => o -> m Settings +toSettings = liftIO . unsafeCastTo Settings + +-- | A convenience alias for `Nothing` :: `Maybe` `Settings`. +noSettings :: Maybe Settings +noSettings = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSettingsMethod (t :: Symbol) (o :: *) :: * where + ResolveSettingsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSettingsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSettingsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSettingsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSettingsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSettingsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSettingsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSettingsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSettingsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSettingsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSettingsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSettingsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSettingsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSettingsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSettingsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSettingsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSettingsMethod "getAllowFileAccessFromFileUrls" o = SettingsGetAllowFileAccessFromFileUrlsMethodInfo + ResolveSettingsMethod "getAllowModalDialogs" o = SettingsGetAllowModalDialogsMethodInfo + ResolveSettingsMethod "getAllowUniversalAccessFromFileUrls" o = SettingsGetAllowUniversalAccessFromFileUrlsMethodInfo + ResolveSettingsMethod "getAutoLoadImages" o = SettingsGetAutoLoadImagesMethodInfo + ResolveSettingsMethod "getCursiveFontFamily" o = SettingsGetCursiveFontFamilyMethodInfo + ResolveSettingsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSettingsMethod "getDefaultCharset" o = SettingsGetDefaultCharsetMethodInfo + ResolveSettingsMethod "getDefaultFontFamily" o = SettingsGetDefaultFontFamilyMethodInfo + ResolveSettingsMethod "getDefaultFontSize" o = SettingsGetDefaultFontSizeMethodInfo + ResolveSettingsMethod "getDefaultMonospaceFontSize" o = SettingsGetDefaultMonospaceFontSizeMethodInfo + ResolveSettingsMethod "getDrawCompositingIndicators" o = SettingsGetDrawCompositingIndicatorsMethodInfo + ResolveSettingsMethod "getEnableAccelerated2dCanvas" o = SettingsGetEnableAccelerated2dCanvasMethodInfo + ResolveSettingsMethod "getEnableBackForwardNavigationGestures" o = SettingsGetEnableBackForwardNavigationGesturesMethodInfo + ResolveSettingsMethod "getEnableCaretBrowsing" o = SettingsGetEnableCaretBrowsingMethodInfo + ResolveSettingsMethod "getEnableDeveloperExtras" o = SettingsGetEnableDeveloperExtrasMethodInfo + ResolveSettingsMethod "getEnableDnsPrefetching" o = SettingsGetEnableDnsPrefetchingMethodInfo + ResolveSettingsMethod "getEnableEncryptedMedia" o = SettingsGetEnableEncryptedMediaMethodInfo + ResolveSettingsMethod "getEnableFrameFlattening" o = SettingsGetEnableFrameFlatteningMethodInfo + ResolveSettingsMethod "getEnableFullscreen" o = SettingsGetEnableFullscreenMethodInfo + ResolveSettingsMethod "getEnableHtml5Database" o = SettingsGetEnableHtml5DatabaseMethodInfo + ResolveSettingsMethod "getEnableHtml5LocalStorage" o = SettingsGetEnableHtml5LocalStorageMethodInfo + ResolveSettingsMethod "getEnableHyperlinkAuditing" o = SettingsGetEnableHyperlinkAuditingMethodInfo + ResolveSettingsMethod "getEnableJava" o = SettingsGetEnableJavaMethodInfo + ResolveSettingsMethod "getEnableJavascript" o = SettingsGetEnableJavascriptMethodInfo + ResolveSettingsMethod "getEnableJavascriptMarkup" o = SettingsGetEnableJavascriptMarkupMethodInfo + ResolveSettingsMethod "getEnableMediaCapabilities" o = SettingsGetEnableMediaCapabilitiesMethodInfo + ResolveSettingsMethod "getEnableMediaStream" o = SettingsGetEnableMediaStreamMethodInfo + ResolveSettingsMethod "getEnableMediasource" o = SettingsGetEnableMediasourceMethodInfo + ResolveSettingsMethod "getEnableMockCaptureDevices" o = SettingsGetEnableMockCaptureDevicesMethodInfo + ResolveSettingsMethod "getEnableOfflineWebApplicationCache" o = SettingsGetEnableOfflineWebApplicationCacheMethodInfo + ResolveSettingsMethod "getEnablePageCache" o = SettingsGetEnablePageCacheMethodInfo + ResolveSettingsMethod "getEnablePlugins" o = SettingsGetEnablePluginsMethodInfo + ResolveSettingsMethod "getEnablePrivateBrowsing" o = SettingsGetEnablePrivateBrowsingMethodInfo + ResolveSettingsMethod "getEnableResizableTextAreas" o = SettingsGetEnableResizableTextAreasMethodInfo + ResolveSettingsMethod "getEnableSiteSpecificQuirks" o = SettingsGetEnableSiteSpecificQuirksMethodInfo + ResolveSettingsMethod "getEnableSmoothScrolling" o = SettingsGetEnableSmoothScrollingMethodInfo + ResolveSettingsMethod "getEnableSpatialNavigation" o = SettingsGetEnableSpatialNavigationMethodInfo + ResolveSettingsMethod "getEnableTabsToLinks" o = SettingsGetEnableTabsToLinksMethodInfo + ResolveSettingsMethod "getEnableWebaudio" o = SettingsGetEnableWebaudioMethodInfo + ResolveSettingsMethod "getEnableWebgl" o = SettingsGetEnableWebglMethodInfo + ResolveSettingsMethod "getEnableWriteConsoleMessagesToStdout" o = SettingsGetEnableWriteConsoleMessagesToStdoutMethodInfo + ResolveSettingsMethod "getEnableXssAuditor" o = SettingsGetEnableXssAuditorMethodInfo + ResolveSettingsMethod "getFantasyFontFamily" o = SettingsGetFantasyFontFamilyMethodInfo + ResolveSettingsMethod "getHardwareAccelerationPolicy" o = SettingsGetHardwareAccelerationPolicyMethodInfo + ResolveSettingsMethod "getJavascriptCanAccessClipboard" o = SettingsGetJavascriptCanAccessClipboardMethodInfo + ResolveSettingsMethod "getJavascriptCanOpenWindowsAutomatically" o = SettingsGetJavascriptCanOpenWindowsAutomaticallyMethodInfo + ResolveSettingsMethod "getLoadIconsIgnoringImageLoadSetting" o = SettingsGetLoadIconsIgnoringImageLoadSettingMethodInfo + ResolveSettingsMethod "getMediaPlaybackAllowsInline" o = SettingsGetMediaPlaybackAllowsInlineMethodInfo + ResolveSettingsMethod "getMediaPlaybackRequiresUserGesture" o = SettingsGetMediaPlaybackRequiresUserGestureMethodInfo + ResolveSettingsMethod "getMinimumFontSize" o = SettingsGetMinimumFontSizeMethodInfo + ResolveSettingsMethod "getMonospaceFontFamily" o = SettingsGetMonospaceFontFamilyMethodInfo + ResolveSettingsMethod "getPictographFontFamily" o = SettingsGetPictographFontFamilyMethodInfo + ResolveSettingsMethod "getPrintBackgrounds" o = SettingsGetPrintBackgroundsMethodInfo + ResolveSettingsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSettingsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSettingsMethod "getSansSerifFontFamily" o = SettingsGetSansSerifFontFamilyMethodInfo + ResolveSettingsMethod "getSerifFontFamily" o = SettingsGetSerifFontFamilyMethodInfo + ResolveSettingsMethod "getUserAgent" o = SettingsGetUserAgentMethodInfo + ResolveSettingsMethod "getZoomTextOnly" o = SettingsGetZoomTextOnlyMethodInfo + ResolveSettingsMethod "setAllowFileAccessFromFileUrls" o = SettingsSetAllowFileAccessFromFileUrlsMethodInfo + ResolveSettingsMethod "setAllowModalDialogs" o = SettingsSetAllowModalDialogsMethodInfo + ResolveSettingsMethod "setAllowUniversalAccessFromFileUrls" o = SettingsSetAllowUniversalAccessFromFileUrlsMethodInfo + ResolveSettingsMethod "setAutoLoadImages" o = SettingsSetAutoLoadImagesMethodInfo + ResolveSettingsMethod "setCursiveFontFamily" o = SettingsSetCursiveFontFamilyMethodInfo + ResolveSettingsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSettingsMethod "setDefaultCharset" o = SettingsSetDefaultCharsetMethodInfo + ResolveSettingsMethod "setDefaultFontFamily" o = SettingsSetDefaultFontFamilyMethodInfo + ResolveSettingsMethod "setDefaultFontSize" o = SettingsSetDefaultFontSizeMethodInfo + ResolveSettingsMethod "setDefaultMonospaceFontSize" o = SettingsSetDefaultMonospaceFontSizeMethodInfo + ResolveSettingsMethod "setDrawCompositingIndicators" o = SettingsSetDrawCompositingIndicatorsMethodInfo + ResolveSettingsMethod "setEnableAccelerated2dCanvas" o = SettingsSetEnableAccelerated2dCanvasMethodInfo + ResolveSettingsMethod "setEnableBackForwardNavigationGestures" o = SettingsSetEnableBackForwardNavigationGesturesMethodInfo + ResolveSettingsMethod "setEnableCaretBrowsing" o = SettingsSetEnableCaretBrowsingMethodInfo + ResolveSettingsMethod "setEnableDeveloperExtras" o = SettingsSetEnableDeveloperExtrasMethodInfo + ResolveSettingsMethod "setEnableDnsPrefetching" o = SettingsSetEnableDnsPrefetchingMethodInfo + ResolveSettingsMethod "setEnableEncryptedMedia" o = SettingsSetEnableEncryptedMediaMethodInfo + ResolveSettingsMethod "setEnableFrameFlattening" o = SettingsSetEnableFrameFlatteningMethodInfo + ResolveSettingsMethod "setEnableFullscreen" o = SettingsSetEnableFullscreenMethodInfo + ResolveSettingsMethod "setEnableHtml5Database" o = SettingsSetEnableHtml5DatabaseMethodInfo + ResolveSettingsMethod "setEnableHtml5LocalStorage" o = SettingsSetEnableHtml5LocalStorageMethodInfo + ResolveSettingsMethod "setEnableHyperlinkAuditing" o = SettingsSetEnableHyperlinkAuditingMethodInfo + ResolveSettingsMethod "setEnableJava" o = SettingsSetEnableJavaMethodInfo + ResolveSettingsMethod "setEnableJavascript" o = SettingsSetEnableJavascriptMethodInfo + ResolveSettingsMethod "setEnableJavascriptMarkup" o = SettingsSetEnableJavascriptMarkupMethodInfo + ResolveSettingsMethod "setEnableMediaCapabilities" o = SettingsSetEnableMediaCapabilitiesMethodInfo + ResolveSettingsMethod "setEnableMediaStream" o = SettingsSetEnableMediaStreamMethodInfo + ResolveSettingsMethod "setEnableMediasource" o = SettingsSetEnableMediasourceMethodInfo + ResolveSettingsMethod "setEnableMockCaptureDevices" o = SettingsSetEnableMockCaptureDevicesMethodInfo + ResolveSettingsMethod "setEnableOfflineWebApplicationCache" o = SettingsSetEnableOfflineWebApplicationCacheMethodInfo + ResolveSettingsMethod "setEnablePageCache" o = SettingsSetEnablePageCacheMethodInfo + ResolveSettingsMethod "setEnablePlugins" o = SettingsSetEnablePluginsMethodInfo + ResolveSettingsMethod "setEnablePrivateBrowsing" o = SettingsSetEnablePrivateBrowsingMethodInfo + ResolveSettingsMethod "setEnableResizableTextAreas" o = SettingsSetEnableResizableTextAreasMethodInfo + ResolveSettingsMethod "setEnableSiteSpecificQuirks" o = SettingsSetEnableSiteSpecificQuirksMethodInfo + ResolveSettingsMethod "setEnableSmoothScrolling" o = SettingsSetEnableSmoothScrollingMethodInfo + ResolveSettingsMethod "setEnableSpatialNavigation" o = SettingsSetEnableSpatialNavigationMethodInfo + ResolveSettingsMethod "setEnableTabsToLinks" o = SettingsSetEnableTabsToLinksMethodInfo + ResolveSettingsMethod "setEnableWebaudio" o = SettingsSetEnableWebaudioMethodInfo + ResolveSettingsMethod "setEnableWebgl" o = SettingsSetEnableWebglMethodInfo + ResolveSettingsMethod "setEnableWriteConsoleMessagesToStdout" o = SettingsSetEnableWriteConsoleMessagesToStdoutMethodInfo + ResolveSettingsMethod "setEnableXssAuditor" o = SettingsSetEnableXssAuditorMethodInfo + ResolveSettingsMethod "setFantasyFontFamily" o = SettingsSetFantasyFontFamilyMethodInfo + ResolveSettingsMethod "setHardwareAccelerationPolicy" o = SettingsSetHardwareAccelerationPolicyMethodInfo + ResolveSettingsMethod "setJavascriptCanAccessClipboard" o = SettingsSetJavascriptCanAccessClipboardMethodInfo + ResolveSettingsMethod "setJavascriptCanOpenWindowsAutomatically" o = SettingsSetJavascriptCanOpenWindowsAutomaticallyMethodInfo + ResolveSettingsMethod "setLoadIconsIgnoringImageLoadSetting" o = SettingsSetLoadIconsIgnoringImageLoadSettingMethodInfo + ResolveSettingsMethod "setMediaPlaybackAllowsInline" o = SettingsSetMediaPlaybackAllowsInlineMethodInfo + ResolveSettingsMethod "setMediaPlaybackRequiresUserGesture" o = SettingsSetMediaPlaybackRequiresUserGestureMethodInfo + ResolveSettingsMethod "setMinimumFontSize" o = SettingsSetMinimumFontSizeMethodInfo + ResolveSettingsMethod "setMonospaceFontFamily" o = SettingsSetMonospaceFontFamilyMethodInfo + ResolveSettingsMethod "setPictographFontFamily" o = SettingsSetPictographFontFamilyMethodInfo + ResolveSettingsMethod "setPrintBackgrounds" o = SettingsSetPrintBackgroundsMethodInfo + ResolveSettingsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSettingsMethod "setSansSerifFontFamily" o = SettingsSetSansSerifFontFamilyMethodInfo + ResolveSettingsMethod "setSerifFontFamily" o = SettingsSetSerifFontFamilyMethodInfo + ResolveSettingsMethod "setUserAgent" o = SettingsSetUserAgentMethodInfo + ResolveSettingsMethod "setUserAgentWithApplicationDetails" o = SettingsSetUserAgentWithApplicationDetailsMethodInfo + ResolveSettingsMethod "setZoomTextOnly" o = SettingsSetZoomTextOnlyMethodInfo + ResolveSettingsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSettingsMethod t Settings, O.MethodInfo info Settings p) => OL.IsLabel t (Settings -> 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 + +-- VVV Prop "allow-file-access-from-file-urls" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@allow-file-access-from-file-urls@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #allowFileAccessFromFileUrls +@ +-} +getSettingsAllowFileAccessFromFileUrls :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsAllowFileAccessFromFileUrls obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-file-access-from-file-urls" + +{- | +Set the value of the “@allow-file-access-from-file-urls@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #allowFileAccessFromFileUrls 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsAllowFileAccessFromFileUrls :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsAllowFileAccessFromFileUrls obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-file-access-from-file-urls" val + +{- | +Construct a `GValueConstruct` with valid value for the “@allow-file-access-from-file-urls@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsAllowFileAccessFromFileUrls :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsAllowFileAccessFromFileUrls val = B.Properties.constructObjectPropertyBool "allow-file-access-from-file-urls" val + +#if ENABLE_OVERLOADING +data SettingsAllowFileAccessFromFileUrlsPropertyInfo +instance AttrInfo SettingsAllowFileAccessFromFileUrlsPropertyInfo where + type AttrAllowedOps SettingsAllowFileAccessFromFileUrlsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsAllowFileAccessFromFileUrlsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsAllowFileAccessFromFileUrlsPropertyInfo = IsSettings + type AttrGetType SettingsAllowFileAccessFromFileUrlsPropertyInfo = Bool + type AttrLabel SettingsAllowFileAccessFromFileUrlsPropertyInfo = "allow-file-access-from-file-urls" + type AttrOrigin SettingsAllowFileAccessFromFileUrlsPropertyInfo = Settings + attrGet _ = getSettingsAllowFileAccessFromFileUrls + attrSet _ = setSettingsAllowFileAccessFromFileUrls + attrConstruct _ = constructSettingsAllowFileAccessFromFileUrls + attrClear _ = undefined +#endif + +-- VVV Prop "allow-modal-dialogs" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@allow-modal-dialogs@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #allowModalDialogs +@ +-} +getSettingsAllowModalDialogs :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsAllowModalDialogs obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-modal-dialogs" + +{- | +Set the value of the “@allow-modal-dialogs@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #allowModalDialogs 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsAllowModalDialogs :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsAllowModalDialogs obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-modal-dialogs" val + +{- | +Construct a `GValueConstruct` with valid value for the “@allow-modal-dialogs@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsAllowModalDialogs :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsAllowModalDialogs val = B.Properties.constructObjectPropertyBool "allow-modal-dialogs" val + +#if ENABLE_OVERLOADING +data SettingsAllowModalDialogsPropertyInfo +instance AttrInfo SettingsAllowModalDialogsPropertyInfo where + type AttrAllowedOps SettingsAllowModalDialogsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsAllowModalDialogsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsAllowModalDialogsPropertyInfo = IsSettings + type AttrGetType SettingsAllowModalDialogsPropertyInfo = Bool + type AttrLabel SettingsAllowModalDialogsPropertyInfo = "allow-modal-dialogs" + type AttrOrigin SettingsAllowModalDialogsPropertyInfo = Settings + attrGet _ = getSettingsAllowModalDialogs + attrSet _ = setSettingsAllowModalDialogs + attrConstruct _ = constructSettingsAllowModalDialogs + attrClear _ = undefined +#endif + +-- VVV Prop "allow-universal-access-from-file-urls" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@allow-universal-access-from-file-urls@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #allowUniversalAccessFromFileUrls +@ +-} +getSettingsAllowUniversalAccessFromFileUrls :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsAllowUniversalAccessFromFileUrls obj = liftIO $ B.Properties.getObjectPropertyBool obj "allow-universal-access-from-file-urls" + +{- | +Set the value of the “@allow-universal-access-from-file-urls@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #allowUniversalAccessFromFileUrls 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsAllowUniversalAccessFromFileUrls :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsAllowUniversalAccessFromFileUrls obj val = liftIO $ B.Properties.setObjectPropertyBool obj "allow-universal-access-from-file-urls" val + +{- | +Construct a `GValueConstruct` with valid value for the “@allow-universal-access-from-file-urls@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsAllowUniversalAccessFromFileUrls :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsAllowUniversalAccessFromFileUrls val = B.Properties.constructObjectPropertyBool "allow-universal-access-from-file-urls" val + +#if ENABLE_OVERLOADING +data SettingsAllowUniversalAccessFromFileUrlsPropertyInfo +instance AttrInfo SettingsAllowUniversalAccessFromFileUrlsPropertyInfo where + type AttrAllowedOps SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = IsSettings + type AttrGetType SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = Bool + type AttrLabel SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = "allow-universal-access-from-file-urls" + type AttrOrigin SettingsAllowUniversalAccessFromFileUrlsPropertyInfo = Settings + attrGet _ = getSettingsAllowUniversalAccessFromFileUrls + attrSet _ = setSettingsAllowUniversalAccessFromFileUrls + attrConstruct _ = constructSettingsAllowUniversalAccessFromFileUrls + attrClear _ = undefined +#endif + +-- VVV Prop "auto-load-images" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@auto-load-images@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #autoLoadImages +@ +-} +getSettingsAutoLoadImages :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsAutoLoadImages obj = liftIO $ B.Properties.getObjectPropertyBool obj "auto-load-images" + +{- | +Set the value of the “@auto-load-images@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #autoLoadImages 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsAutoLoadImages :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsAutoLoadImages obj val = liftIO $ B.Properties.setObjectPropertyBool obj "auto-load-images" val + +{- | +Construct a `GValueConstruct` with valid value for the “@auto-load-images@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsAutoLoadImages :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsAutoLoadImages val = B.Properties.constructObjectPropertyBool "auto-load-images" val + +#if ENABLE_OVERLOADING +data SettingsAutoLoadImagesPropertyInfo +instance AttrInfo SettingsAutoLoadImagesPropertyInfo where + type AttrAllowedOps SettingsAutoLoadImagesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsAutoLoadImagesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsAutoLoadImagesPropertyInfo = IsSettings + type AttrGetType SettingsAutoLoadImagesPropertyInfo = Bool + type AttrLabel SettingsAutoLoadImagesPropertyInfo = "auto-load-images" + type AttrOrigin SettingsAutoLoadImagesPropertyInfo = Settings + attrGet _ = getSettingsAutoLoadImages + attrSet _ = setSettingsAutoLoadImages + attrConstruct _ = constructSettingsAutoLoadImages + attrClear _ = undefined +#endif + +-- VVV Prop "cursive-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@cursive-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #cursiveFontFamily +@ +-} +getSettingsCursiveFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsCursiveFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsCursiveFontFamily" $ B.Properties.getObjectPropertyString obj "cursive-font-family" + +{- | +Set the value of the “@cursive-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #cursiveFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsCursiveFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsCursiveFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "cursive-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@cursive-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsCursiveFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsCursiveFontFamily val = B.Properties.constructObjectPropertyString "cursive-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsCursiveFontFamilyPropertyInfo +instance AttrInfo SettingsCursiveFontFamilyPropertyInfo where + type AttrAllowedOps SettingsCursiveFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsCursiveFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsCursiveFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsCursiveFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsCursiveFontFamilyPropertyInfo = "cursive-font-family" + type AttrOrigin SettingsCursiveFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsCursiveFontFamily + attrSet _ = setSettingsCursiveFontFamily + attrConstruct _ = constructSettingsCursiveFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "default-charset" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@default-charset@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #defaultCharset +@ +-} +getSettingsDefaultCharset :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsDefaultCharset obj = liftIO $ checkUnexpectedNothing "getSettingsDefaultCharset" $ B.Properties.getObjectPropertyString obj "default-charset" + +{- | +Set the value of the “@default-charset@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #defaultCharset 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsDefaultCharset :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsDefaultCharset obj val = liftIO $ B.Properties.setObjectPropertyString obj "default-charset" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@default-charset@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsDefaultCharset :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsDefaultCharset val = B.Properties.constructObjectPropertyString "default-charset" (Just val) + +#if ENABLE_OVERLOADING +data SettingsDefaultCharsetPropertyInfo +instance AttrInfo SettingsDefaultCharsetPropertyInfo where + type AttrAllowedOps SettingsDefaultCharsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsDefaultCharsetPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsDefaultCharsetPropertyInfo = IsSettings + type AttrGetType SettingsDefaultCharsetPropertyInfo = T.Text + type AttrLabel SettingsDefaultCharsetPropertyInfo = "default-charset" + type AttrOrigin SettingsDefaultCharsetPropertyInfo = Settings + attrGet _ = getSettingsDefaultCharset + attrSet _ = setSettingsDefaultCharset + attrConstruct _ = constructSettingsDefaultCharset + attrClear _ = undefined +#endif + +-- VVV Prop "default-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@default-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #defaultFontFamily +@ +-} +getSettingsDefaultFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsDefaultFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsDefaultFontFamily" $ B.Properties.getObjectPropertyString obj "default-font-family" + +{- | +Set the value of the “@default-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #defaultFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsDefaultFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsDefaultFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "default-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@default-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsDefaultFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsDefaultFontFamily val = B.Properties.constructObjectPropertyString "default-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsDefaultFontFamilyPropertyInfo +instance AttrInfo SettingsDefaultFontFamilyPropertyInfo where + type AttrAllowedOps SettingsDefaultFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsDefaultFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsDefaultFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsDefaultFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsDefaultFontFamilyPropertyInfo = "default-font-family" + type AttrOrigin SettingsDefaultFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsDefaultFontFamily + attrSet _ = setSettingsDefaultFontFamily + attrConstruct _ = constructSettingsDefaultFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "default-font-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@default-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #defaultFontSize +@ +-} +getSettingsDefaultFontSize :: (MonadIO m, IsSettings o) => o -> m Word32 +getSettingsDefaultFontSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "default-font-size" + +{- | +Set the value of the “@default-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #defaultFontSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsDefaultFontSize :: (MonadIO m, IsSettings o) => o -> Word32 -> m () +setSettingsDefaultFontSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "default-font-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@default-font-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsDefaultFontSize :: (IsSettings o) => Word32 -> IO (GValueConstruct o) +constructSettingsDefaultFontSize val = B.Properties.constructObjectPropertyUInt32 "default-font-size" val + +#if ENABLE_OVERLOADING +data SettingsDefaultFontSizePropertyInfo +instance AttrInfo SettingsDefaultFontSizePropertyInfo where + type AttrAllowedOps SettingsDefaultFontSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsDefaultFontSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint SettingsDefaultFontSizePropertyInfo = IsSettings + type AttrGetType SettingsDefaultFontSizePropertyInfo = Word32 + type AttrLabel SettingsDefaultFontSizePropertyInfo = "default-font-size" + type AttrOrigin SettingsDefaultFontSizePropertyInfo = Settings + attrGet _ = getSettingsDefaultFontSize + attrSet _ = setSettingsDefaultFontSize + attrConstruct _ = constructSettingsDefaultFontSize + attrClear _ = undefined +#endif + +-- VVV Prop "default-monospace-font-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@default-monospace-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #defaultMonospaceFontSize +@ +-} +getSettingsDefaultMonospaceFontSize :: (MonadIO m, IsSettings o) => o -> m Word32 +getSettingsDefaultMonospaceFontSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "default-monospace-font-size" + +{- | +Set the value of the “@default-monospace-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #defaultMonospaceFontSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsDefaultMonospaceFontSize :: (MonadIO m, IsSettings o) => o -> Word32 -> m () +setSettingsDefaultMonospaceFontSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "default-monospace-font-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@default-monospace-font-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsDefaultMonospaceFontSize :: (IsSettings o) => Word32 -> IO (GValueConstruct o) +constructSettingsDefaultMonospaceFontSize val = B.Properties.constructObjectPropertyUInt32 "default-monospace-font-size" val + +#if ENABLE_OVERLOADING +data SettingsDefaultMonospaceFontSizePropertyInfo +instance AttrInfo SettingsDefaultMonospaceFontSizePropertyInfo where + type AttrAllowedOps SettingsDefaultMonospaceFontSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsDefaultMonospaceFontSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint SettingsDefaultMonospaceFontSizePropertyInfo = IsSettings + type AttrGetType SettingsDefaultMonospaceFontSizePropertyInfo = Word32 + type AttrLabel SettingsDefaultMonospaceFontSizePropertyInfo = "default-monospace-font-size" + type AttrOrigin SettingsDefaultMonospaceFontSizePropertyInfo = Settings + attrGet _ = getSettingsDefaultMonospaceFontSize + attrSet _ = setSettingsDefaultMonospaceFontSize + attrConstruct _ = constructSettingsDefaultMonospaceFontSize + attrClear _ = undefined +#endif + +-- VVV Prop "draw-compositing-indicators" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@draw-compositing-indicators@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #drawCompositingIndicators +@ +-} +getSettingsDrawCompositingIndicators :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsDrawCompositingIndicators obj = liftIO $ B.Properties.getObjectPropertyBool obj "draw-compositing-indicators" + +{- | +Set the value of the “@draw-compositing-indicators@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #drawCompositingIndicators 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsDrawCompositingIndicators :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsDrawCompositingIndicators obj val = liftIO $ B.Properties.setObjectPropertyBool obj "draw-compositing-indicators" val + +{- | +Construct a `GValueConstruct` with valid value for the “@draw-compositing-indicators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsDrawCompositingIndicators :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsDrawCompositingIndicators val = B.Properties.constructObjectPropertyBool "draw-compositing-indicators" val + +#if ENABLE_OVERLOADING +data SettingsDrawCompositingIndicatorsPropertyInfo +instance AttrInfo SettingsDrawCompositingIndicatorsPropertyInfo where + type AttrAllowedOps SettingsDrawCompositingIndicatorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsDrawCompositingIndicatorsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsDrawCompositingIndicatorsPropertyInfo = IsSettings + type AttrGetType SettingsDrawCompositingIndicatorsPropertyInfo = Bool + type AttrLabel SettingsDrawCompositingIndicatorsPropertyInfo = "draw-compositing-indicators" + type AttrOrigin SettingsDrawCompositingIndicatorsPropertyInfo = Settings + attrGet _ = getSettingsDrawCompositingIndicators + attrSet _ = setSettingsDrawCompositingIndicators + attrConstruct _ = constructSettingsDrawCompositingIndicators + attrClear _ = undefined +#endif + +-- VVV Prop "enable-accelerated-2d-canvas" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-accelerated-2d-canvas@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableAccelerated2dCanvas +@ +-} +getSettingsEnableAccelerated2dCanvas :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableAccelerated2dCanvas obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-accelerated-2d-canvas" + +{- | +Set the value of the “@enable-accelerated-2d-canvas@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableAccelerated2dCanvas 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableAccelerated2dCanvas :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableAccelerated2dCanvas obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-accelerated-2d-canvas" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-accelerated-2d-canvas@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableAccelerated2dCanvas :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableAccelerated2dCanvas val = B.Properties.constructObjectPropertyBool "enable-accelerated-2d-canvas" val + +#if ENABLE_OVERLOADING +data SettingsEnableAccelerated2dCanvasPropertyInfo +instance AttrInfo SettingsEnableAccelerated2dCanvasPropertyInfo where + type AttrAllowedOps SettingsEnableAccelerated2dCanvasPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableAccelerated2dCanvasPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableAccelerated2dCanvasPropertyInfo = IsSettings + type AttrGetType SettingsEnableAccelerated2dCanvasPropertyInfo = Bool + type AttrLabel SettingsEnableAccelerated2dCanvasPropertyInfo = "enable-accelerated-2d-canvas" + type AttrOrigin SettingsEnableAccelerated2dCanvasPropertyInfo = Settings + attrGet _ = getSettingsEnableAccelerated2dCanvas + attrSet _ = setSettingsEnableAccelerated2dCanvas + attrConstruct _ = constructSettingsEnableAccelerated2dCanvas + attrClear _ = undefined +#endif + +-- VVV Prop "enable-back-forward-navigation-gestures" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-back-forward-navigation-gestures@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableBackForwardNavigationGestures +@ +-} +getSettingsEnableBackForwardNavigationGestures :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableBackForwardNavigationGestures obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-back-forward-navigation-gestures" + +{- | +Set the value of the “@enable-back-forward-navigation-gestures@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableBackForwardNavigationGestures 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableBackForwardNavigationGestures :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableBackForwardNavigationGestures obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-back-forward-navigation-gestures" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-back-forward-navigation-gestures@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableBackForwardNavigationGestures :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableBackForwardNavigationGestures val = B.Properties.constructObjectPropertyBool "enable-back-forward-navigation-gestures" val + +#if ENABLE_OVERLOADING +data SettingsEnableBackForwardNavigationGesturesPropertyInfo +instance AttrInfo SettingsEnableBackForwardNavigationGesturesPropertyInfo where + type AttrAllowedOps SettingsEnableBackForwardNavigationGesturesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableBackForwardNavigationGesturesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableBackForwardNavigationGesturesPropertyInfo = IsSettings + type AttrGetType SettingsEnableBackForwardNavigationGesturesPropertyInfo = Bool + type AttrLabel SettingsEnableBackForwardNavigationGesturesPropertyInfo = "enable-back-forward-navigation-gestures" + type AttrOrigin SettingsEnableBackForwardNavigationGesturesPropertyInfo = Settings + attrGet _ = getSettingsEnableBackForwardNavigationGestures + attrSet _ = setSettingsEnableBackForwardNavigationGestures + attrConstruct _ = constructSettingsEnableBackForwardNavigationGestures + attrClear _ = undefined +#endif + +-- VVV Prop "enable-caret-browsing" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-caret-browsing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableCaretBrowsing +@ +-} +getSettingsEnableCaretBrowsing :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableCaretBrowsing obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-caret-browsing" + +{- | +Set the value of the “@enable-caret-browsing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableCaretBrowsing 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableCaretBrowsing :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableCaretBrowsing obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-caret-browsing" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-caret-browsing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableCaretBrowsing :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableCaretBrowsing val = B.Properties.constructObjectPropertyBool "enable-caret-browsing" val + +#if ENABLE_OVERLOADING +data SettingsEnableCaretBrowsingPropertyInfo +instance AttrInfo SettingsEnableCaretBrowsingPropertyInfo where + type AttrAllowedOps SettingsEnableCaretBrowsingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableCaretBrowsingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableCaretBrowsingPropertyInfo = IsSettings + type AttrGetType SettingsEnableCaretBrowsingPropertyInfo = Bool + type AttrLabel SettingsEnableCaretBrowsingPropertyInfo = "enable-caret-browsing" + type AttrOrigin SettingsEnableCaretBrowsingPropertyInfo = Settings + attrGet _ = getSettingsEnableCaretBrowsing + attrSet _ = setSettingsEnableCaretBrowsing + attrConstruct _ = constructSettingsEnableCaretBrowsing + attrClear _ = undefined +#endif + +-- VVV Prop "enable-developer-extras" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-developer-extras@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableDeveloperExtras +@ +-} +getSettingsEnableDeveloperExtras :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableDeveloperExtras obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-developer-extras" + +{- | +Set the value of the “@enable-developer-extras@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableDeveloperExtras 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableDeveloperExtras :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableDeveloperExtras obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-developer-extras" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-developer-extras@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableDeveloperExtras :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableDeveloperExtras val = B.Properties.constructObjectPropertyBool "enable-developer-extras" val + +#if ENABLE_OVERLOADING +data SettingsEnableDeveloperExtrasPropertyInfo +instance AttrInfo SettingsEnableDeveloperExtrasPropertyInfo where + type AttrAllowedOps SettingsEnableDeveloperExtrasPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableDeveloperExtrasPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableDeveloperExtrasPropertyInfo = IsSettings + type AttrGetType SettingsEnableDeveloperExtrasPropertyInfo = Bool + type AttrLabel SettingsEnableDeveloperExtrasPropertyInfo = "enable-developer-extras" + type AttrOrigin SettingsEnableDeveloperExtrasPropertyInfo = Settings + attrGet _ = getSettingsEnableDeveloperExtras + attrSet _ = setSettingsEnableDeveloperExtras + attrConstruct _ = constructSettingsEnableDeveloperExtras + attrClear _ = undefined +#endif + +-- VVV Prop "enable-dns-prefetching" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-dns-prefetching@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableDnsPrefetching +@ +-} +getSettingsEnableDnsPrefetching :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableDnsPrefetching obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-dns-prefetching" + +{- | +Set the value of the “@enable-dns-prefetching@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableDnsPrefetching 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableDnsPrefetching :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableDnsPrefetching obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-dns-prefetching" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-dns-prefetching@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableDnsPrefetching :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableDnsPrefetching val = B.Properties.constructObjectPropertyBool "enable-dns-prefetching" val + +#if ENABLE_OVERLOADING +data SettingsEnableDnsPrefetchingPropertyInfo +instance AttrInfo SettingsEnableDnsPrefetchingPropertyInfo where + type AttrAllowedOps SettingsEnableDnsPrefetchingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableDnsPrefetchingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableDnsPrefetchingPropertyInfo = IsSettings + type AttrGetType SettingsEnableDnsPrefetchingPropertyInfo = Bool + type AttrLabel SettingsEnableDnsPrefetchingPropertyInfo = "enable-dns-prefetching" + type AttrOrigin SettingsEnableDnsPrefetchingPropertyInfo = Settings + attrGet _ = getSettingsEnableDnsPrefetching + attrSet _ = setSettingsEnableDnsPrefetching + attrConstruct _ = constructSettingsEnableDnsPrefetching + attrClear _ = undefined +#endif + +-- VVV Prop "enable-encrypted-media" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-encrypted-media@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableEncryptedMedia +@ +-} +getSettingsEnableEncryptedMedia :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableEncryptedMedia obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-encrypted-media" + +{- | +Set the value of the “@enable-encrypted-media@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableEncryptedMedia 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableEncryptedMedia :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableEncryptedMedia obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-encrypted-media" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-encrypted-media@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableEncryptedMedia :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableEncryptedMedia val = B.Properties.constructObjectPropertyBool "enable-encrypted-media" val + +#if ENABLE_OVERLOADING +data SettingsEnableEncryptedMediaPropertyInfo +instance AttrInfo SettingsEnableEncryptedMediaPropertyInfo where + type AttrAllowedOps SettingsEnableEncryptedMediaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableEncryptedMediaPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableEncryptedMediaPropertyInfo = IsSettings + type AttrGetType SettingsEnableEncryptedMediaPropertyInfo = Bool + type AttrLabel SettingsEnableEncryptedMediaPropertyInfo = "enable-encrypted-media" + type AttrOrigin SettingsEnableEncryptedMediaPropertyInfo = Settings + attrGet _ = getSettingsEnableEncryptedMedia + attrSet _ = setSettingsEnableEncryptedMedia + attrConstruct _ = constructSettingsEnableEncryptedMedia + attrClear _ = undefined +#endif + +-- VVV Prop "enable-frame-flattening" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-frame-flattening@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableFrameFlattening +@ +-} +getSettingsEnableFrameFlattening :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableFrameFlattening obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-frame-flattening" + +{- | +Set the value of the “@enable-frame-flattening@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableFrameFlattening 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableFrameFlattening :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableFrameFlattening obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-frame-flattening" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-frame-flattening@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableFrameFlattening :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableFrameFlattening val = B.Properties.constructObjectPropertyBool "enable-frame-flattening" val + +#if ENABLE_OVERLOADING +data SettingsEnableFrameFlatteningPropertyInfo +instance AttrInfo SettingsEnableFrameFlatteningPropertyInfo where + type AttrAllowedOps SettingsEnableFrameFlatteningPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableFrameFlatteningPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableFrameFlatteningPropertyInfo = IsSettings + type AttrGetType SettingsEnableFrameFlatteningPropertyInfo = Bool + type AttrLabel SettingsEnableFrameFlatteningPropertyInfo = "enable-frame-flattening" + type AttrOrigin SettingsEnableFrameFlatteningPropertyInfo = Settings + attrGet _ = getSettingsEnableFrameFlattening + attrSet _ = setSettingsEnableFrameFlattening + attrConstruct _ = constructSettingsEnableFrameFlattening + attrClear _ = undefined +#endif + +-- VVV Prop "enable-fullscreen" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-fullscreen@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableFullscreen +@ +-} +getSettingsEnableFullscreen :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableFullscreen obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-fullscreen" + +{- | +Set the value of the “@enable-fullscreen@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableFullscreen 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableFullscreen :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableFullscreen obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-fullscreen" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-fullscreen@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableFullscreen :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableFullscreen val = B.Properties.constructObjectPropertyBool "enable-fullscreen" val + +#if ENABLE_OVERLOADING +data SettingsEnableFullscreenPropertyInfo +instance AttrInfo SettingsEnableFullscreenPropertyInfo where + type AttrAllowedOps SettingsEnableFullscreenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableFullscreenPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableFullscreenPropertyInfo = IsSettings + type AttrGetType SettingsEnableFullscreenPropertyInfo = Bool + type AttrLabel SettingsEnableFullscreenPropertyInfo = "enable-fullscreen" + type AttrOrigin SettingsEnableFullscreenPropertyInfo = Settings + attrGet _ = getSettingsEnableFullscreen + attrSet _ = setSettingsEnableFullscreen + attrConstruct _ = constructSettingsEnableFullscreen + attrClear _ = undefined +#endif + +-- VVV Prop "enable-html5-database" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-html5-database@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableHtml5Database +@ +-} +getSettingsEnableHtml5Database :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableHtml5Database obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-html5-database" + +{- | +Set the value of the “@enable-html5-database@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableHtml5Database 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableHtml5Database :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableHtml5Database obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-html5-database" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-html5-database@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableHtml5Database :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableHtml5Database val = B.Properties.constructObjectPropertyBool "enable-html5-database" val + +#if ENABLE_OVERLOADING +data SettingsEnableHtml5DatabasePropertyInfo +instance AttrInfo SettingsEnableHtml5DatabasePropertyInfo where + type AttrAllowedOps SettingsEnableHtml5DatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableHtml5DatabasePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableHtml5DatabasePropertyInfo = IsSettings + type AttrGetType SettingsEnableHtml5DatabasePropertyInfo = Bool + type AttrLabel SettingsEnableHtml5DatabasePropertyInfo = "enable-html5-database" + type AttrOrigin SettingsEnableHtml5DatabasePropertyInfo = Settings + attrGet _ = getSettingsEnableHtml5Database + attrSet _ = setSettingsEnableHtml5Database + attrConstruct _ = constructSettingsEnableHtml5Database + attrClear _ = undefined +#endif + +-- VVV Prop "enable-html5-local-storage" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-html5-local-storage@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableHtml5LocalStorage +@ +-} +getSettingsEnableHtml5LocalStorage :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableHtml5LocalStorage obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-html5-local-storage" + +{- | +Set the value of the “@enable-html5-local-storage@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableHtml5LocalStorage 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableHtml5LocalStorage :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableHtml5LocalStorage obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-html5-local-storage" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-html5-local-storage@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableHtml5LocalStorage :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableHtml5LocalStorage val = B.Properties.constructObjectPropertyBool "enable-html5-local-storage" val + +#if ENABLE_OVERLOADING +data SettingsEnableHtml5LocalStoragePropertyInfo +instance AttrInfo SettingsEnableHtml5LocalStoragePropertyInfo where + type AttrAllowedOps SettingsEnableHtml5LocalStoragePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableHtml5LocalStoragePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableHtml5LocalStoragePropertyInfo = IsSettings + type AttrGetType SettingsEnableHtml5LocalStoragePropertyInfo = Bool + type AttrLabel SettingsEnableHtml5LocalStoragePropertyInfo = "enable-html5-local-storage" + type AttrOrigin SettingsEnableHtml5LocalStoragePropertyInfo = Settings + attrGet _ = getSettingsEnableHtml5LocalStorage + attrSet _ = setSettingsEnableHtml5LocalStorage + attrConstruct _ = constructSettingsEnableHtml5LocalStorage + attrClear _ = undefined +#endif + +-- VVV Prop "enable-hyperlink-auditing" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-hyperlink-auditing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableHyperlinkAuditing +@ +-} +getSettingsEnableHyperlinkAuditing :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableHyperlinkAuditing obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-hyperlink-auditing" + +{- | +Set the value of the “@enable-hyperlink-auditing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableHyperlinkAuditing 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableHyperlinkAuditing :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableHyperlinkAuditing obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-hyperlink-auditing" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-hyperlink-auditing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableHyperlinkAuditing :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableHyperlinkAuditing val = B.Properties.constructObjectPropertyBool "enable-hyperlink-auditing" val + +#if ENABLE_OVERLOADING +data SettingsEnableHyperlinkAuditingPropertyInfo +instance AttrInfo SettingsEnableHyperlinkAuditingPropertyInfo where + type AttrAllowedOps SettingsEnableHyperlinkAuditingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableHyperlinkAuditingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableHyperlinkAuditingPropertyInfo = IsSettings + type AttrGetType SettingsEnableHyperlinkAuditingPropertyInfo = Bool + type AttrLabel SettingsEnableHyperlinkAuditingPropertyInfo = "enable-hyperlink-auditing" + type AttrOrigin SettingsEnableHyperlinkAuditingPropertyInfo = Settings + attrGet _ = getSettingsEnableHyperlinkAuditing + attrSet _ = setSettingsEnableHyperlinkAuditing + attrConstruct _ = constructSettingsEnableHyperlinkAuditing + attrClear _ = undefined +#endif + +-- VVV Prop "enable-java" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-java@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableJava +@ +-} +getSettingsEnableJava :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableJava obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-java" + +{- | +Set the value of the “@enable-java@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableJava 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableJava :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableJava obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-java" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-java@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableJava :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableJava val = B.Properties.constructObjectPropertyBool "enable-java" val + +#if ENABLE_OVERLOADING +data SettingsEnableJavaPropertyInfo +instance AttrInfo SettingsEnableJavaPropertyInfo where + type AttrAllowedOps SettingsEnableJavaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableJavaPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableJavaPropertyInfo = IsSettings + type AttrGetType SettingsEnableJavaPropertyInfo = Bool + type AttrLabel SettingsEnableJavaPropertyInfo = "enable-java" + type AttrOrigin SettingsEnableJavaPropertyInfo = Settings + attrGet _ = getSettingsEnableJava + attrSet _ = setSettingsEnableJava + attrConstruct _ = constructSettingsEnableJava + attrClear _ = undefined +#endif + +-- VVV Prop "enable-javascript" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-javascript@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableJavascript +@ +-} +getSettingsEnableJavascript :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableJavascript obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-javascript" + +{- | +Set the value of the “@enable-javascript@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableJavascript 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableJavascript :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableJavascript obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-javascript" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-javascript@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableJavascript :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableJavascript val = B.Properties.constructObjectPropertyBool "enable-javascript" val + +#if ENABLE_OVERLOADING +data SettingsEnableJavascriptPropertyInfo +instance AttrInfo SettingsEnableJavascriptPropertyInfo where + type AttrAllowedOps SettingsEnableJavascriptPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableJavascriptPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableJavascriptPropertyInfo = IsSettings + type AttrGetType SettingsEnableJavascriptPropertyInfo = Bool + type AttrLabel SettingsEnableJavascriptPropertyInfo = "enable-javascript" + type AttrOrigin SettingsEnableJavascriptPropertyInfo = Settings + attrGet _ = getSettingsEnableJavascript + attrSet _ = setSettingsEnableJavascript + attrConstruct _ = constructSettingsEnableJavascript + attrClear _ = undefined +#endif + +-- VVV Prop "enable-javascript-markup" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-javascript-markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableJavascriptMarkup +@ +-} +getSettingsEnableJavascriptMarkup :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableJavascriptMarkup obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-javascript-markup" + +{- | +Set the value of the “@enable-javascript-markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableJavascriptMarkup 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableJavascriptMarkup :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableJavascriptMarkup obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-javascript-markup" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-javascript-markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableJavascriptMarkup :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableJavascriptMarkup val = B.Properties.constructObjectPropertyBool "enable-javascript-markup" val + +#if ENABLE_OVERLOADING +data SettingsEnableJavascriptMarkupPropertyInfo +instance AttrInfo SettingsEnableJavascriptMarkupPropertyInfo where + type AttrAllowedOps SettingsEnableJavascriptMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableJavascriptMarkupPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableJavascriptMarkupPropertyInfo = IsSettings + type AttrGetType SettingsEnableJavascriptMarkupPropertyInfo = Bool + type AttrLabel SettingsEnableJavascriptMarkupPropertyInfo = "enable-javascript-markup" + type AttrOrigin SettingsEnableJavascriptMarkupPropertyInfo = Settings + attrGet _ = getSettingsEnableJavascriptMarkup + attrSet _ = setSettingsEnableJavascriptMarkup + attrConstruct _ = constructSettingsEnableJavascriptMarkup + attrClear _ = undefined +#endif + +-- VVV Prop "enable-media-capabilities" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-media-capabilities@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableMediaCapabilities +@ +-} +getSettingsEnableMediaCapabilities :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableMediaCapabilities obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-media-capabilities" + +{- | +Set the value of the “@enable-media-capabilities@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableMediaCapabilities 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableMediaCapabilities :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableMediaCapabilities obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-media-capabilities" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-media-capabilities@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableMediaCapabilities :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableMediaCapabilities val = B.Properties.constructObjectPropertyBool "enable-media-capabilities" val + +#if ENABLE_OVERLOADING +data SettingsEnableMediaCapabilitiesPropertyInfo +instance AttrInfo SettingsEnableMediaCapabilitiesPropertyInfo where + type AttrAllowedOps SettingsEnableMediaCapabilitiesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableMediaCapabilitiesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableMediaCapabilitiesPropertyInfo = IsSettings + type AttrGetType SettingsEnableMediaCapabilitiesPropertyInfo = Bool + type AttrLabel SettingsEnableMediaCapabilitiesPropertyInfo = "enable-media-capabilities" + type AttrOrigin SettingsEnableMediaCapabilitiesPropertyInfo = Settings + attrGet _ = getSettingsEnableMediaCapabilities + attrSet _ = setSettingsEnableMediaCapabilities + attrConstruct _ = constructSettingsEnableMediaCapabilities + attrClear _ = undefined +#endif + +-- VVV Prop "enable-media-stream" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-media-stream@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableMediaStream +@ +-} +getSettingsEnableMediaStream :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableMediaStream obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-media-stream" + +{- | +Set the value of the “@enable-media-stream@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableMediaStream 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableMediaStream :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableMediaStream obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-media-stream" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-media-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableMediaStream :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableMediaStream val = B.Properties.constructObjectPropertyBool "enable-media-stream" val + +#if ENABLE_OVERLOADING +data SettingsEnableMediaStreamPropertyInfo +instance AttrInfo SettingsEnableMediaStreamPropertyInfo where + type AttrAllowedOps SettingsEnableMediaStreamPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableMediaStreamPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableMediaStreamPropertyInfo = IsSettings + type AttrGetType SettingsEnableMediaStreamPropertyInfo = Bool + type AttrLabel SettingsEnableMediaStreamPropertyInfo = "enable-media-stream" + type AttrOrigin SettingsEnableMediaStreamPropertyInfo = Settings + attrGet _ = getSettingsEnableMediaStream + attrSet _ = setSettingsEnableMediaStream + attrConstruct _ = constructSettingsEnableMediaStream + attrClear _ = undefined +#endif + +-- VVV Prop "enable-mediasource" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-mediasource@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableMediasource +@ +-} +getSettingsEnableMediasource :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableMediasource obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-mediasource" + +{- | +Set the value of the “@enable-mediasource@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableMediasource 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableMediasource :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableMediasource obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-mediasource" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-mediasource@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableMediasource :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableMediasource val = B.Properties.constructObjectPropertyBool "enable-mediasource" val + +#if ENABLE_OVERLOADING +data SettingsEnableMediasourcePropertyInfo +instance AttrInfo SettingsEnableMediasourcePropertyInfo where + type AttrAllowedOps SettingsEnableMediasourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableMediasourcePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableMediasourcePropertyInfo = IsSettings + type AttrGetType SettingsEnableMediasourcePropertyInfo = Bool + type AttrLabel SettingsEnableMediasourcePropertyInfo = "enable-mediasource" + type AttrOrigin SettingsEnableMediasourcePropertyInfo = Settings + attrGet _ = getSettingsEnableMediasource + attrSet _ = setSettingsEnableMediasource + attrConstruct _ = constructSettingsEnableMediasource + attrClear _ = undefined +#endif + +-- VVV Prop "enable-mock-capture-devices" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-mock-capture-devices@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableMockCaptureDevices +@ +-} +getSettingsEnableMockCaptureDevices :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableMockCaptureDevices obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-mock-capture-devices" + +{- | +Set the value of the “@enable-mock-capture-devices@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableMockCaptureDevices 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableMockCaptureDevices :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableMockCaptureDevices obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-mock-capture-devices" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-mock-capture-devices@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableMockCaptureDevices :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableMockCaptureDevices val = B.Properties.constructObjectPropertyBool "enable-mock-capture-devices" val + +#if ENABLE_OVERLOADING +data SettingsEnableMockCaptureDevicesPropertyInfo +instance AttrInfo SettingsEnableMockCaptureDevicesPropertyInfo where + type AttrAllowedOps SettingsEnableMockCaptureDevicesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableMockCaptureDevicesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableMockCaptureDevicesPropertyInfo = IsSettings + type AttrGetType SettingsEnableMockCaptureDevicesPropertyInfo = Bool + type AttrLabel SettingsEnableMockCaptureDevicesPropertyInfo = "enable-mock-capture-devices" + type AttrOrigin SettingsEnableMockCaptureDevicesPropertyInfo = Settings + attrGet _ = getSettingsEnableMockCaptureDevices + attrSet _ = setSettingsEnableMockCaptureDevices + attrConstruct _ = constructSettingsEnableMockCaptureDevices + attrClear _ = undefined +#endif + +-- VVV Prop "enable-offline-web-application-cache" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-offline-web-application-cache@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableOfflineWebApplicationCache +@ +-} +getSettingsEnableOfflineWebApplicationCache :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableOfflineWebApplicationCache obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-offline-web-application-cache" + +{- | +Set the value of the “@enable-offline-web-application-cache@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableOfflineWebApplicationCache 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableOfflineWebApplicationCache :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableOfflineWebApplicationCache obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-offline-web-application-cache" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-offline-web-application-cache@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableOfflineWebApplicationCache :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableOfflineWebApplicationCache val = B.Properties.constructObjectPropertyBool "enable-offline-web-application-cache" val + +#if ENABLE_OVERLOADING +data SettingsEnableOfflineWebApplicationCachePropertyInfo +instance AttrInfo SettingsEnableOfflineWebApplicationCachePropertyInfo where + type AttrAllowedOps SettingsEnableOfflineWebApplicationCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableOfflineWebApplicationCachePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableOfflineWebApplicationCachePropertyInfo = IsSettings + type AttrGetType SettingsEnableOfflineWebApplicationCachePropertyInfo = Bool + type AttrLabel SettingsEnableOfflineWebApplicationCachePropertyInfo = "enable-offline-web-application-cache" + type AttrOrigin SettingsEnableOfflineWebApplicationCachePropertyInfo = Settings + attrGet _ = getSettingsEnableOfflineWebApplicationCache + attrSet _ = setSettingsEnableOfflineWebApplicationCache + attrConstruct _ = constructSettingsEnableOfflineWebApplicationCache + attrClear _ = undefined +#endif + +-- VVV Prop "enable-page-cache" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-page-cache@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enablePageCache +@ +-} +getSettingsEnablePageCache :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnablePageCache obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-page-cache" + +{- | +Set the value of the “@enable-page-cache@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enablePageCache 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnablePageCache :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnablePageCache obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-page-cache" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-page-cache@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnablePageCache :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnablePageCache val = B.Properties.constructObjectPropertyBool "enable-page-cache" val + +#if ENABLE_OVERLOADING +data SettingsEnablePageCachePropertyInfo +instance AttrInfo SettingsEnablePageCachePropertyInfo where + type AttrAllowedOps SettingsEnablePageCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnablePageCachePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnablePageCachePropertyInfo = IsSettings + type AttrGetType SettingsEnablePageCachePropertyInfo = Bool + type AttrLabel SettingsEnablePageCachePropertyInfo = "enable-page-cache" + type AttrOrigin SettingsEnablePageCachePropertyInfo = Settings + attrGet _ = getSettingsEnablePageCache + attrSet _ = setSettingsEnablePageCache + attrConstruct _ = constructSettingsEnablePageCache + attrClear _ = undefined +#endif + +-- VVV Prop "enable-plugins" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-plugins@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enablePlugins +@ +-} +getSettingsEnablePlugins :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnablePlugins obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-plugins" + +{- | +Set the value of the “@enable-plugins@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enablePlugins 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnablePlugins :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnablePlugins obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-plugins" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-plugins@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnablePlugins :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnablePlugins val = B.Properties.constructObjectPropertyBool "enable-plugins" val + +#if ENABLE_OVERLOADING +data SettingsEnablePluginsPropertyInfo +instance AttrInfo SettingsEnablePluginsPropertyInfo where + type AttrAllowedOps SettingsEnablePluginsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnablePluginsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnablePluginsPropertyInfo = IsSettings + type AttrGetType SettingsEnablePluginsPropertyInfo = Bool + type AttrLabel SettingsEnablePluginsPropertyInfo = "enable-plugins" + type AttrOrigin SettingsEnablePluginsPropertyInfo = Settings + attrGet _ = getSettingsEnablePlugins + attrSet _ = setSettingsEnablePlugins + attrConstruct _ = constructSettingsEnablePlugins + attrClear _ = undefined +#endif + +-- VVV Prop "enable-private-browsing" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-private-browsing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enablePrivateBrowsing +@ +-} +getSettingsEnablePrivateBrowsing :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnablePrivateBrowsing obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-private-browsing" + +{- | +Set the value of the “@enable-private-browsing@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enablePrivateBrowsing 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnablePrivateBrowsing :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnablePrivateBrowsing obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-private-browsing" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-private-browsing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnablePrivateBrowsing :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnablePrivateBrowsing val = B.Properties.constructObjectPropertyBool "enable-private-browsing" val + +#if ENABLE_OVERLOADING +data SettingsEnablePrivateBrowsingPropertyInfo +instance AttrInfo SettingsEnablePrivateBrowsingPropertyInfo where + type AttrAllowedOps SettingsEnablePrivateBrowsingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnablePrivateBrowsingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnablePrivateBrowsingPropertyInfo = IsSettings + type AttrGetType SettingsEnablePrivateBrowsingPropertyInfo = Bool + type AttrLabel SettingsEnablePrivateBrowsingPropertyInfo = "enable-private-browsing" + type AttrOrigin SettingsEnablePrivateBrowsingPropertyInfo = Settings + attrGet _ = getSettingsEnablePrivateBrowsing + attrSet _ = setSettingsEnablePrivateBrowsing + attrConstruct _ = constructSettingsEnablePrivateBrowsing + attrClear _ = undefined +#endif + +-- VVV Prop "enable-resizable-text-areas" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-resizable-text-areas@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableResizableTextAreas +@ +-} +getSettingsEnableResizableTextAreas :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableResizableTextAreas obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-resizable-text-areas" + +{- | +Set the value of the “@enable-resizable-text-areas@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableResizableTextAreas 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableResizableTextAreas :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableResizableTextAreas obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-resizable-text-areas" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-resizable-text-areas@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableResizableTextAreas :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableResizableTextAreas val = B.Properties.constructObjectPropertyBool "enable-resizable-text-areas" val + +#if ENABLE_OVERLOADING +data SettingsEnableResizableTextAreasPropertyInfo +instance AttrInfo SettingsEnableResizableTextAreasPropertyInfo where + type AttrAllowedOps SettingsEnableResizableTextAreasPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableResizableTextAreasPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableResizableTextAreasPropertyInfo = IsSettings + type AttrGetType SettingsEnableResizableTextAreasPropertyInfo = Bool + type AttrLabel SettingsEnableResizableTextAreasPropertyInfo = "enable-resizable-text-areas" + type AttrOrigin SettingsEnableResizableTextAreasPropertyInfo = Settings + attrGet _ = getSettingsEnableResizableTextAreas + attrSet _ = setSettingsEnableResizableTextAreas + attrConstruct _ = constructSettingsEnableResizableTextAreas + attrClear _ = undefined +#endif + +-- VVV Prop "enable-site-specific-quirks" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-site-specific-quirks@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableSiteSpecificQuirks +@ +-} +getSettingsEnableSiteSpecificQuirks :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableSiteSpecificQuirks obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-site-specific-quirks" + +{- | +Set the value of the “@enable-site-specific-quirks@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableSiteSpecificQuirks 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableSiteSpecificQuirks :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableSiteSpecificQuirks obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-site-specific-quirks" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-site-specific-quirks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableSiteSpecificQuirks :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableSiteSpecificQuirks val = B.Properties.constructObjectPropertyBool "enable-site-specific-quirks" val + +#if ENABLE_OVERLOADING +data SettingsEnableSiteSpecificQuirksPropertyInfo +instance AttrInfo SettingsEnableSiteSpecificQuirksPropertyInfo where + type AttrAllowedOps SettingsEnableSiteSpecificQuirksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableSiteSpecificQuirksPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableSiteSpecificQuirksPropertyInfo = IsSettings + type AttrGetType SettingsEnableSiteSpecificQuirksPropertyInfo = Bool + type AttrLabel SettingsEnableSiteSpecificQuirksPropertyInfo = "enable-site-specific-quirks" + type AttrOrigin SettingsEnableSiteSpecificQuirksPropertyInfo = Settings + attrGet _ = getSettingsEnableSiteSpecificQuirks + attrSet _ = setSettingsEnableSiteSpecificQuirks + attrConstruct _ = constructSettingsEnableSiteSpecificQuirks + attrClear _ = undefined +#endif + +-- VVV Prop "enable-smooth-scrolling" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-smooth-scrolling@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableSmoothScrolling +@ +-} +getSettingsEnableSmoothScrolling :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableSmoothScrolling obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-smooth-scrolling" + +{- | +Set the value of the “@enable-smooth-scrolling@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableSmoothScrolling 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableSmoothScrolling :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableSmoothScrolling obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-smooth-scrolling" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-smooth-scrolling@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableSmoothScrolling :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableSmoothScrolling val = B.Properties.constructObjectPropertyBool "enable-smooth-scrolling" val + +#if ENABLE_OVERLOADING +data SettingsEnableSmoothScrollingPropertyInfo +instance AttrInfo SettingsEnableSmoothScrollingPropertyInfo where + type AttrAllowedOps SettingsEnableSmoothScrollingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableSmoothScrollingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableSmoothScrollingPropertyInfo = IsSettings + type AttrGetType SettingsEnableSmoothScrollingPropertyInfo = Bool + type AttrLabel SettingsEnableSmoothScrollingPropertyInfo = "enable-smooth-scrolling" + type AttrOrigin SettingsEnableSmoothScrollingPropertyInfo = Settings + attrGet _ = getSettingsEnableSmoothScrolling + attrSet _ = setSettingsEnableSmoothScrolling + attrConstruct _ = constructSettingsEnableSmoothScrolling + attrClear _ = undefined +#endif + +-- VVV Prop "enable-spatial-navigation" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-spatial-navigation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableSpatialNavigation +@ +-} +getSettingsEnableSpatialNavigation :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableSpatialNavigation obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-spatial-navigation" + +{- | +Set the value of the “@enable-spatial-navigation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableSpatialNavigation 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableSpatialNavigation :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableSpatialNavigation obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-spatial-navigation" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-spatial-navigation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableSpatialNavigation :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableSpatialNavigation val = B.Properties.constructObjectPropertyBool "enable-spatial-navigation" val + +#if ENABLE_OVERLOADING +data SettingsEnableSpatialNavigationPropertyInfo +instance AttrInfo SettingsEnableSpatialNavigationPropertyInfo where + type AttrAllowedOps SettingsEnableSpatialNavigationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableSpatialNavigationPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableSpatialNavigationPropertyInfo = IsSettings + type AttrGetType SettingsEnableSpatialNavigationPropertyInfo = Bool + type AttrLabel SettingsEnableSpatialNavigationPropertyInfo = "enable-spatial-navigation" + type AttrOrigin SettingsEnableSpatialNavigationPropertyInfo = Settings + attrGet _ = getSettingsEnableSpatialNavigation + attrSet _ = setSettingsEnableSpatialNavigation + attrConstruct _ = constructSettingsEnableSpatialNavigation + attrClear _ = undefined +#endif + +-- VVV Prop "enable-tabs-to-links" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-tabs-to-links@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableTabsToLinks +@ +-} +getSettingsEnableTabsToLinks :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableTabsToLinks obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-tabs-to-links" + +{- | +Set the value of the “@enable-tabs-to-links@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableTabsToLinks 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableTabsToLinks :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableTabsToLinks obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-tabs-to-links" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-tabs-to-links@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableTabsToLinks :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableTabsToLinks val = B.Properties.constructObjectPropertyBool "enable-tabs-to-links" val + +#if ENABLE_OVERLOADING +data SettingsEnableTabsToLinksPropertyInfo +instance AttrInfo SettingsEnableTabsToLinksPropertyInfo where + type AttrAllowedOps SettingsEnableTabsToLinksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableTabsToLinksPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableTabsToLinksPropertyInfo = IsSettings + type AttrGetType SettingsEnableTabsToLinksPropertyInfo = Bool + type AttrLabel SettingsEnableTabsToLinksPropertyInfo = "enable-tabs-to-links" + type AttrOrigin SettingsEnableTabsToLinksPropertyInfo = Settings + attrGet _ = getSettingsEnableTabsToLinks + attrSet _ = setSettingsEnableTabsToLinks + attrConstruct _ = constructSettingsEnableTabsToLinks + attrClear _ = undefined +#endif + +-- VVV Prop "enable-webaudio" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-webaudio@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableWebaudio +@ +-} +getSettingsEnableWebaudio :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableWebaudio obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-webaudio" + +{- | +Set the value of the “@enable-webaudio@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableWebaudio 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableWebaudio :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableWebaudio obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-webaudio" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-webaudio@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableWebaudio :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableWebaudio val = B.Properties.constructObjectPropertyBool "enable-webaudio" val + +#if ENABLE_OVERLOADING +data SettingsEnableWebaudioPropertyInfo +instance AttrInfo SettingsEnableWebaudioPropertyInfo where + type AttrAllowedOps SettingsEnableWebaudioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableWebaudioPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableWebaudioPropertyInfo = IsSettings + type AttrGetType SettingsEnableWebaudioPropertyInfo = Bool + type AttrLabel SettingsEnableWebaudioPropertyInfo = "enable-webaudio" + type AttrOrigin SettingsEnableWebaudioPropertyInfo = Settings + attrGet _ = getSettingsEnableWebaudio + attrSet _ = setSettingsEnableWebaudio + attrConstruct _ = constructSettingsEnableWebaudio + attrClear _ = undefined +#endif + +-- VVV Prop "enable-webgl" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-webgl@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableWebgl +@ +-} +getSettingsEnableWebgl :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableWebgl obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-webgl" + +{- | +Set the value of the “@enable-webgl@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableWebgl 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableWebgl :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableWebgl obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-webgl" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-webgl@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableWebgl :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableWebgl val = B.Properties.constructObjectPropertyBool "enable-webgl" val + +#if ENABLE_OVERLOADING +data SettingsEnableWebglPropertyInfo +instance AttrInfo SettingsEnableWebglPropertyInfo where + type AttrAllowedOps SettingsEnableWebglPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableWebglPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableWebglPropertyInfo = IsSettings + type AttrGetType SettingsEnableWebglPropertyInfo = Bool + type AttrLabel SettingsEnableWebglPropertyInfo = "enable-webgl" + type AttrOrigin SettingsEnableWebglPropertyInfo = Settings + attrGet _ = getSettingsEnableWebgl + attrSet _ = setSettingsEnableWebgl + attrConstruct _ = constructSettingsEnableWebgl + attrClear _ = undefined +#endif + +-- VVV Prop "enable-write-console-messages-to-stdout" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-write-console-messages-to-stdout@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableWriteConsoleMessagesToStdout +@ +-} +getSettingsEnableWriteConsoleMessagesToStdout :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableWriteConsoleMessagesToStdout obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-write-console-messages-to-stdout" + +{- | +Set the value of the “@enable-write-console-messages-to-stdout@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableWriteConsoleMessagesToStdout 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableWriteConsoleMessagesToStdout :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableWriteConsoleMessagesToStdout obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-write-console-messages-to-stdout" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-write-console-messages-to-stdout@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableWriteConsoleMessagesToStdout :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableWriteConsoleMessagesToStdout val = B.Properties.constructObjectPropertyBool "enable-write-console-messages-to-stdout" val + +#if ENABLE_OVERLOADING +data SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo +instance AttrInfo SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo where + type AttrAllowedOps SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = IsSettings + type AttrGetType SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = Bool + type AttrLabel SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = "enable-write-console-messages-to-stdout" + type AttrOrigin SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo = Settings + attrGet _ = getSettingsEnableWriteConsoleMessagesToStdout + attrSet _ = setSettingsEnableWriteConsoleMessagesToStdout + attrConstruct _ = constructSettingsEnableWriteConsoleMessagesToStdout + attrClear _ = undefined +#endif + +-- VVV Prop "enable-xss-auditor" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-xss-auditor@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #enableXssAuditor +@ +-} +getSettingsEnableXssAuditor :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsEnableXssAuditor obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-xss-auditor" + +{- | +Set the value of the “@enable-xss-auditor@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #enableXssAuditor 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsEnableXssAuditor :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsEnableXssAuditor obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-xss-auditor" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-xss-auditor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsEnableXssAuditor :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsEnableXssAuditor val = B.Properties.constructObjectPropertyBool "enable-xss-auditor" val + +#if ENABLE_OVERLOADING +data SettingsEnableXssAuditorPropertyInfo +instance AttrInfo SettingsEnableXssAuditorPropertyInfo where + type AttrAllowedOps SettingsEnableXssAuditorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsEnableXssAuditorPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsEnableXssAuditorPropertyInfo = IsSettings + type AttrGetType SettingsEnableXssAuditorPropertyInfo = Bool + type AttrLabel SettingsEnableXssAuditorPropertyInfo = "enable-xss-auditor" + type AttrOrigin SettingsEnableXssAuditorPropertyInfo = Settings + attrGet _ = getSettingsEnableXssAuditor + attrSet _ = setSettingsEnableXssAuditor + attrConstruct _ = constructSettingsEnableXssAuditor + attrClear _ = undefined +#endif + +-- VVV Prop "fantasy-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@fantasy-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #fantasyFontFamily +@ +-} +getSettingsFantasyFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsFantasyFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsFantasyFontFamily" $ B.Properties.getObjectPropertyString obj "fantasy-font-family" + +{- | +Set the value of the “@fantasy-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #fantasyFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsFantasyFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsFantasyFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "fantasy-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@fantasy-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsFantasyFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsFantasyFontFamily val = B.Properties.constructObjectPropertyString "fantasy-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsFantasyFontFamilyPropertyInfo +instance AttrInfo SettingsFantasyFontFamilyPropertyInfo where + type AttrAllowedOps SettingsFantasyFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsFantasyFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsFantasyFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsFantasyFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsFantasyFontFamilyPropertyInfo = "fantasy-font-family" + type AttrOrigin SettingsFantasyFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsFantasyFontFamily + attrSet _ = setSettingsFantasyFontFamily + attrConstruct _ = constructSettingsFantasyFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "hardware-acceleration-policy" + -- Type: TInterface (Name {namespace = "WebKit2", name = "HardwareAccelerationPolicy"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@hardware-acceleration-policy@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #hardwareAccelerationPolicy +@ +-} +getSettingsHardwareAccelerationPolicy :: (MonadIO m, IsSettings o) => o -> m WebKit2.Enums.HardwareAccelerationPolicy +getSettingsHardwareAccelerationPolicy obj = liftIO $ B.Properties.getObjectPropertyEnum obj "hardware-acceleration-policy" + +{- | +Set the value of the “@hardware-acceleration-policy@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #hardwareAccelerationPolicy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsHardwareAccelerationPolicy :: (MonadIO m, IsSettings o) => o -> WebKit2.Enums.HardwareAccelerationPolicy -> m () +setSettingsHardwareAccelerationPolicy obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "hardware-acceleration-policy" val + +{- | +Construct a `GValueConstruct` with valid value for the “@hardware-acceleration-policy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsHardwareAccelerationPolicy :: (IsSettings o) => WebKit2.Enums.HardwareAccelerationPolicy -> IO (GValueConstruct o) +constructSettingsHardwareAccelerationPolicy val = B.Properties.constructObjectPropertyEnum "hardware-acceleration-policy" val + +#if ENABLE_OVERLOADING +data SettingsHardwareAccelerationPolicyPropertyInfo +instance AttrInfo SettingsHardwareAccelerationPolicyPropertyInfo where + type AttrAllowedOps SettingsHardwareAccelerationPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsHardwareAccelerationPolicyPropertyInfo = (~) WebKit2.Enums.HardwareAccelerationPolicy + type AttrBaseTypeConstraint SettingsHardwareAccelerationPolicyPropertyInfo = IsSettings + type AttrGetType SettingsHardwareAccelerationPolicyPropertyInfo = WebKit2.Enums.HardwareAccelerationPolicy + type AttrLabel SettingsHardwareAccelerationPolicyPropertyInfo = "hardware-acceleration-policy" + type AttrOrigin SettingsHardwareAccelerationPolicyPropertyInfo = Settings + attrGet _ = getSettingsHardwareAccelerationPolicy + attrSet _ = setSettingsHardwareAccelerationPolicy + attrConstruct _ = constructSettingsHardwareAccelerationPolicy + attrClear _ = undefined +#endif + +-- VVV Prop "javascript-can-access-clipboard" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@javascript-can-access-clipboard@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #javascriptCanAccessClipboard +@ +-} +getSettingsJavascriptCanAccessClipboard :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsJavascriptCanAccessClipboard obj = liftIO $ B.Properties.getObjectPropertyBool obj "javascript-can-access-clipboard" + +{- | +Set the value of the “@javascript-can-access-clipboard@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #javascriptCanAccessClipboard 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsJavascriptCanAccessClipboard :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsJavascriptCanAccessClipboard obj val = liftIO $ B.Properties.setObjectPropertyBool obj "javascript-can-access-clipboard" val + +{- | +Construct a `GValueConstruct` with valid value for the “@javascript-can-access-clipboard@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsJavascriptCanAccessClipboard :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsJavascriptCanAccessClipboard val = B.Properties.constructObjectPropertyBool "javascript-can-access-clipboard" val + +#if ENABLE_OVERLOADING +data SettingsJavascriptCanAccessClipboardPropertyInfo +instance AttrInfo SettingsJavascriptCanAccessClipboardPropertyInfo where + type AttrAllowedOps SettingsJavascriptCanAccessClipboardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsJavascriptCanAccessClipboardPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsJavascriptCanAccessClipboardPropertyInfo = IsSettings + type AttrGetType SettingsJavascriptCanAccessClipboardPropertyInfo = Bool + type AttrLabel SettingsJavascriptCanAccessClipboardPropertyInfo = "javascript-can-access-clipboard" + type AttrOrigin SettingsJavascriptCanAccessClipboardPropertyInfo = Settings + attrGet _ = getSettingsJavascriptCanAccessClipboard + attrSet _ = setSettingsJavascriptCanAccessClipboard + attrConstruct _ = constructSettingsJavascriptCanAccessClipboard + attrClear _ = undefined +#endif + +-- VVV Prop "javascript-can-open-windows-automatically" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@javascript-can-open-windows-automatically@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #javascriptCanOpenWindowsAutomatically +@ +-} +getSettingsJavascriptCanOpenWindowsAutomatically :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsJavascriptCanOpenWindowsAutomatically obj = liftIO $ B.Properties.getObjectPropertyBool obj "javascript-can-open-windows-automatically" + +{- | +Set the value of the “@javascript-can-open-windows-automatically@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #javascriptCanOpenWindowsAutomatically 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsJavascriptCanOpenWindowsAutomatically :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsJavascriptCanOpenWindowsAutomatically obj val = liftIO $ B.Properties.setObjectPropertyBool obj "javascript-can-open-windows-automatically" val + +{- | +Construct a `GValueConstruct` with valid value for the “@javascript-can-open-windows-automatically@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsJavascriptCanOpenWindowsAutomatically :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsJavascriptCanOpenWindowsAutomatically val = B.Properties.constructObjectPropertyBool "javascript-can-open-windows-automatically" val + +#if ENABLE_OVERLOADING +data SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo +instance AttrInfo SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo where + type AttrAllowedOps SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = IsSettings + type AttrGetType SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = Bool + type AttrLabel SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = "javascript-can-open-windows-automatically" + type AttrOrigin SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo = Settings + attrGet _ = getSettingsJavascriptCanOpenWindowsAutomatically + attrSet _ = setSettingsJavascriptCanOpenWindowsAutomatically + attrConstruct _ = constructSettingsJavascriptCanOpenWindowsAutomatically + attrClear _ = undefined +#endif + +-- VVV Prop "load-icons-ignoring-image-load-setting" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@load-icons-ignoring-image-load-setting@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #loadIconsIgnoringImageLoadSetting +@ +-} +getSettingsLoadIconsIgnoringImageLoadSetting :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsLoadIconsIgnoringImageLoadSetting obj = liftIO $ B.Properties.getObjectPropertyBool obj "load-icons-ignoring-image-load-setting" + +{- | +Set the value of the “@load-icons-ignoring-image-load-setting@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #loadIconsIgnoringImageLoadSetting 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsLoadIconsIgnoringImageLoadSetting :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsLoadIconsIgnoringImageLoadSetting obj val = liftIO $ B.Properties.setObjectPropertyBool obj "load-icons-ignoring-image-load-setting" val + +{- | +Construct a `GValueConstruct` with valid value for the “@load-icons-ignoring-image-load-setting@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsLoadIconsIgnoringImageLoadSetting :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsLoadIconsIgnoringImageLoadSetting val = B.Properties.constructObjectPropertyBool "load-icons-ignoring-image-load-setting" val + +#if ENABLE_OVERLOADING +data SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo +instance AttrInfo SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo where + type AttrAllowedOps SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = IsSettings + type AttrGetType SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = Bool + type AttrLabel SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = "load-icons-ignoring-image-load-setting" + type AttrOrigin SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo = Settings + attrGet _ = getSettingsLoadIconsIgnoringImageLoadSetting + attrSet _ = setSettingsLoadIconsIgnoringImageLoadSetting + attrConstruct _ = constructSettingsLoadIconsIgnoringImageLoadSetting + attrClear _ = undefined +#endif + +-- VVV Prop "media-playback-allows-inline" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@media-playback-allows-inline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #mediaPlaybackAllowsInline +@ +-} +getSettingsMediaPlaybackAllowsInline :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsMediaPlaybackAllowsInline obj = liftIO $ B.Properties.getObjectPropertyBool obj "media-playback-allows-inline" + +{- | +Set the value of the “@media-playback-allows-inline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #mediaPlaybackAllowsInline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsMediaPlaybackAllowsInline :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsMediaPlaybackAllowsInline obj val = liftIO $ B.Properties.setObjectPropertyBool obj "media-playback-allows-inline" val + +{- | +Construct a `GValueConstruct` with valid value for the “@media-playback-allows-inline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsMediaPlaybackAllowsInline :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsMediaPlaybackAllowsInline val = B.Properties.constructObjectPropertyBool "media-playback-allows-inline" val + +#if ENABLE_OVERLOADING +data SettingsMediaPlaybackAllowsInlinePropertyInfo +instance AttrInfo SettingsMediaPlaybackAllowsInlinePropertyInfo where + type AttrAllowedOps SettingsMediaPlaybackAllowsInlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsMediaPlaybackAllowsInlinePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsMediaPlaybackAllowsInlinePropertyInfo = IsSettings + type AttrGetType SettingsMediaPlaybackAllowsInlinePropertyInfo = Bool + type AttrLabel SettingsMediaPlaybackAllowsInlinePropertyInfo = "media-playback-allows-inline" + type AttrOrigin SettingsMediaPlaybackAllowsInlinePropertyInfo = Settings + attrGet _ = getSettingsMediaPlaybackAllowsInline + attrSet _ = setSettingsMediaPlaybackAllowsInline + attrConstruct _ = constructSettingsMediaPlaybackAllowsInline + attrClear _ = undefined +#endif + +-- VVV Prop "media-playback-requires-user-gesture" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@media-playback-requires-user-gesture@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #mediaPlaybackRequiresUserGesture +@ +-} +getSettingsMediaPlaybackRequiresUserGesture :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsMediaPlaybackRequiresUserGesture obj = liftIO $ B.Properties.getObjectPropertyBool obj "media-playback-requires-user-gesture" + +{- | +Set the value of the “@media-playback-requires-user-gesture@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #mediaPlaybackRequiresUserGesture 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsMediaPlaybackRequiresUserGesture :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsMediaPlaybackRequiresUserGesture obj val = liftIO $ B.Properties.setObjectPropertyBool obj "media-playback-requires-user-gesture" val + +{- | +Construct a `GValueConstruct` with valid value for the “@media-playback-requires-user-gesture@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsMediaPlaybackRequiresUserGesture :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsMediaPlaybackRequiresUserGesture val = B.Properties.constructObjectPropertyBool "media-playback-requires-user-gesture" val + +#if ENABLE_OVERLOADING +data SettingsMediaPlaybackRequiresUserGesturePropertyInfo +instance AttrInfo SettingsMediaPlaybackRequiresUserGesturePropertyInfo where + type AttrAllowedOps SettingsMediaPlaybackRequiresUserGesturePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsMediaPlaybackRequiresUserGesturePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsMediaPlaybackRequiresUserGesturePropertyInfo = IsSettings + type AttrGetType SettingsMediaPlaybackRequiresUserGesturePropertyInfo = Bool + type AttrLabel SettingsMediaPlaybackRequiresUserGesturePropertyInfo = "media-playback-requires-user-gesture" + type AttrOrigin SettingsMediaPlaybackRequiresUserGesturePropertyInfo = Settings + attrGet _ = getSettingsMediaPlaybackRequiresUserGesture + attrSet _ = setSettingsMediaPlaybackRequiresUserGesture + attrConstruct _ = constructSettingsMediaPlaybackRequiresUserGesture + attrClear _ = undefined +#endif + +-- VVV Prop "minimum-font-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@minimum-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #minimumFontSize +@ +-} +getSettingsMinimumFontSize :: (MonadIO m, IsSettings o) => o -> m Word32 +getSettingsMinimumFontSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "minimum-font-size" + +{- | +Set the value of the “@minimum-font-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #minimumFontSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsMinimumFontSize :: (MonadIO m, IsSettings o) => o -> Word32 -> m () +setSettingsMinimumFontSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "minimum-font-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@minimum-font-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsMinimumFontSize :: (IsSettings o) => Word32 -> IO (GValueConstruct o) +constructSettingsMinimumFontSize val = B.Properties.constructObjectPropertyUInt32 "minimum-font-size" val + +#if ENABLE_OVERLOADING +data SettingsMinimumFontSizePropertyInfo +instance AttrInfo SettingsMinimumFontSizePropertyInfo where + type AttrAllowedOps SettingsMinimumFontSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsMinimumFontSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint SettingsMinimumFontSizePropertyInfo = IsSettings + type AttrGetType SettingsMinimumFontSizePropertyInfo = Word32 + type AttrLabel SettingsMinimumFontSizePropertyInfo = "minimum-font-size" + type AttrOrigin SettingsMinimumFontSizePropertyInfo = Settings + attrGet _ = getSettingsMinimumFontSize + attrSet _ = setSettingsMinimumFontSize + attrConstruct _ = constructSettingsMinimumFontSize + attrClear _ = undefined +#endif + +-- VVV Prop "monospace-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@monospace-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #monospaceFontFamily +@ +-} +getSettingsMonospaceFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsMonospaceFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsMonospaceFontFamily" $ B.Properties.getObjectPropertyString obj "monospace-font-family" + +{- | +Set the value of the “@monospace-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #monospaceFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsMonospaceFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsMonospaceFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "monospace-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@monospace-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsMonospaceFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsMonospaceFontFamily val = B.Properties.constructObjectPropertyString "monospace-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsMonospaceFontFamilyPropertyInfo +instance AttrInfo SettingsMonospaceFontFamilyPropertyInfo where + type AttrAllowedOps SettingsMonospaceFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsMonospaceFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsMonospaceFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsMonospaceFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsMonospaceFontFamilyPropertyInfo = "monospace-font-family" + type AttrOrigin SettingsMonospaceFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsMonospaceFontFamily + attrSet _ = setSettingsMonospaceFontFamily + attrConstruct _ = constructSettingsMonospaceFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "pictograph-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@pictograph-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #pictographFontFamily +@ +-} +getSettingsPictographFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsPictographFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsPictographFontFamily" $ B.Properties.getObjectPropertyString obj "pictograph-font-family" + +{- | +Set the value of the “@pictograph-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #pictographFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsPictographFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsPictographFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "pictograph-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@pictograph-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsPictographFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsPictographFontFamily val = B.Properties.constructObjectPropertyString "pictograph-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsPictographFontFamilyPropertyInfo +instance AttrInfo SettingsPictographFontFamilyPropertyInfo where + type AttrAllowedOps SettingsPictographFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsPictographFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsPictographFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsPictographFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsPictographFontFamilyPropertyInfo = "pictograph-font-family" + type AttrOrigin SettingsPictographFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsPictographFontFamily + attrSet _ = setSettingsPictographFontFamily + attrConstruct _ = constructSettingsPictographFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "print-backgrounds" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@print-backgrounds@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #printBackgrounds +@ +-} +getSettingsPrintBackgrounds :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsPrintBackgrounds obj = liftIO $ B.Properties.getObjectPropertyBool obj "print-backgrounds" + +{- | +Set the value of the “@print-backgrounds@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #printBackgrounds 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsPrintBackgrounds :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsPrintBackgrounds obj val = liftIO $ B.Properties.setObjectPropertyBool obj "print-backgrounds" val + +{- | +Construct a `GValueConstruct` with valid value for the “@print-backgrounds@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsPrintBackgrounds :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsPrintBackgrounds val = B.Properties.constructObjectPropertyBool "print-backgrounds" val + +#if ENABLE_OVERLOADING +data SettingsPrintBackgroundsPropertyInfo +instance AttrInfo SettingsPrintBackgroundsPropertyInfo where + type AttrAllowedOps SettingsPrintBackgroundsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsPrintBackgroundsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsPrintBackgroundsPropertyInfo = IsSettings + type AttrGetType SettingsPrintBackgroundsPropertyInfo = Bool + type AttrLabel SettingsPrintBackgroundsPropertyInfo = "print-backgrounds" + type AttrOrigin SettingsPrintBackgroundsPropertyInfo = Settings + attrGet _ = getSettingsPrintBackgrounds + attrSet _ = setSettingsPrintBackgrounds + attrConstruct _ = constructSettingsPrintBackgrounds + attrClear _ = undefined +#endif + +-- VVV Prop "sans-serif-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@sans-serif-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #sansSerifFontFamily +@ +-} +getSettingsSansSerifFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsSansSerifFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsSansSerifFontFamily" $ B.Properties.getObjectPropertyString obj "sans-serif-font-family" + +{- | +Set the value of the “@sans-serif-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #sansSerifFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsSansSerifFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsSansSerifFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "sans-serif-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@sans-serif-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsSansSerifFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsSansSerifFontFamily val = B.Properties.constructObjectPropertyString "sans-serif-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsSansSerifFontFamilyPropertyInfo +instance AttrInfo SettingsSansSerifFontFamilyPropertyInfo where + type AttrAllowedOps SettingsSansSerifFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsSansSerifFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsSansSerifFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsSansSerifFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsSansSerifFontFamilyPropertyInfo = "sans-serif-font-family" + type AttrOrigin SettingsSansSerifFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsSansSerifFontFamily + attrSet _ = setSettingsSansSerifFontFamily + attrConstruct _ = constructSettingsSansSerifFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "serif-font-family" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@serif-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #serifFontFamily +@ +-} +getSettingsSerifFontFamily :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsSerifFontFamily obj = liftIO $ checkUnexpectedNothing "getSettingsSerifFontFamily" $ B.Properties.getObjectPropertyString obj "serif-font-family" + +{- | +Set the value of the “@serif-font-family@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #serifFontFamily 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsSerifFontFamily :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsSerifFontFamily obj val = liftIO $ B.Properties.setObjectPropertyString obj "serif-font-family" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@serif-font-family@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsSerifFontFamily :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsSerifFontFamily val = B.Properties.constructObjectPropertyString "serif-font-family" (Just val) + +#if ENABLE_OVERLOADING +data SettingsSerifFontFamilyPropertyInfo +instance AttrInfo SettingsSerifFontFamilyPropertyInfo where + type AttrAllowedOps SettingsSerifFontFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsSerifFontFamilyPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsSerifFontFamilyPropertyInfo = IsSettings + type AttrGetType SettingsSerifFontFamilyPropertyInfo = T.Text + type AttrLabel SettingsSerifFontFamilyPropertyInfo = "serif-font-family" + type AttrOrigin SettingsSerifFontFamilyPropertyInfo = Settings + attrGet _ = getSettingsSerifFontFamily + attrSet _ = setSettingsSerifFontFamily + attrConstruct _ = constructSettingsSerifFontFamily + attrClear _ = undefined +#endif + +-- VVV Prop "user-agent" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@user-agent@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #userAgent +@ +-} +getSettingsUserAgent :: (MonadIO m, IsSettings o) => o -> m T.Text +getSettingsUserAgent obj = liftIO $ checkUnexpectedNothing "getSettingsUserAgent" $ B.Properties.getObjectPropertyString obj "user-agent" + +{- | +Set the value of the “@user-agent@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #userAgent 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsUserAgent :: (MonadIO m, IsSettings o) => o -> T.Text -> m () +setSettingsUserAgent obj val = liftIO $ B.Properties.setObjectPropertyString obj "user-agent" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@user-agent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsUserAgent :: (IsSettings o) => T.Text -> IO (GValueConstruct o) +constructSettingsUserAgent val = B.Properties.constructObjectPropertyString "user-agent" (Just val) + +{- | +Set the value of the “@user-agent@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #userAgent +@ +-} +clearSettingsUserAgent :: (MonadIO m, IsSettings o) => o -> m () +clearSettingsUserAgent obj = liftIO $ B.Properties.setObjectPropertyString obj "user-agent" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data SettingsUserAgentPropertyInfo +instance AttrInfo SettingsUserAgentPropertyInfo where + type AttrAllowedOps SettingsUserAgentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SettingsUserAgentPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SettingsUserAgentPropertyInfo = IsSettings + type AttrGetType SettingsUserAgentPropertyInfo = T.Text + type AttrLabel SettingsUserAgentPropertyInfo = "user-agent" + type AttrOrigin SettingsUserAgentPropertyInfo = Settings + attrGet _ = getSettingsUserAgent + attrSet _ = setSettingsUserAgent + attrConstruct _ = constructSettingsUserAgent + attrClear _ = clearSettingsUserAgent +#endif + +-- VVV Prop "zoom-text-only" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@zoom-text-only@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' settings #zoomTextOnly +@ +-} +getSettingsZoomTextOnly :: (MonadIO m, IsSettings o) => o -> m Bool +getSettingsZoomTextOnly obj = liftIO $ B.Properties.getObjectPropertyBool obj "zoom-text-only" + +{- | +Set the value of the “@zoom-text-only@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' settings [ #zoomTextOnly 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSettingsZoomTextOnly :: (MonadIO m, IsSettings o) => o -> Bool -> m () +setSettingsZoomTextOnly obj val = liftIO $ B.Properties.setObjectPropertyBool obj "zoom-text-only" val + +{- | +Construct a `GValueConstruct` with valid value for the “@zoom-text-only@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSettingsZoomTextOnly :: (IsSettings o) => Bool -> IO (GValueConstruct o) +constructSettingsZoomTextOnly val = B.Properties.constructObjectPropertyBool "zoom-text-only" val + +#if ENABLE_OVERLOADING +data SettingsZoomTextOnlyPropertyInfo +instance AttrInfo SettingsZoomTextOnlyPropertyInfo where + type AttrAllowedOps SettingsZoomTextOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SettingsZoomTextOnlyPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SettingsZoomTextOnlyPropertyInfo = IsSettings + type AttrGetType SettingsZoomTextOnlyPropertyInfo = Bool + type AttrLabel SettingsZoomTextOnlyPropertyInfo = "zoom-text-only" + type AttrOrigin SettingsZoomTextOnlyPropertyInfo = Settings + attrGet _ = getSettingsZoomTextOnly + attrSet _ = setSettingsZoomTextOnly + attrConstruct _ = constructSettingsZoomTextOnly + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Settings +type instance O.AttributeList Settings = SettingsAttributeList +type SettingsAttributeList = ('[ '("allowFileAccessFromFileUrls", SettingsAllowFileAccessFromFileUrlsPropertyInfo), '("allowModalDialogs", SettingsAllowModalDialogsPropertyInfo), '("allowUniversalAccessFromFileUrls", SettingsAllowUniversalAccessFromFileUrlsPropertyInfo), '("autoLoadImages", SettingsAutoLoadImagesPropertyInfo), '("cursiveFontFamily", SettingsCursiveFontFamilyPropertyInfo), '("defaultCharset", SettingsDefaultCharsetPropertyInfo), '("defaultFontFamily", SettingsDefaultFontFamilyPropertyInfo), '("defaultFontSize", SettingsDefaultFontSizePropertyInfo), '("defaultMonospaceFontSize", SettingsDefaultMonospaceFontSizePropertyInfo), '("drawCompositingIndicators", SettingsDrawCompositingIndicatorsPropertyInfo), '("enableAccelerated2dCanvas", SettingsEnableAccelerated2dCanvasPropertyInfo), '("enableBackForwardNavigationGestures", SettingsEnableBackForwardNavigationGesturesPropertyInfo), '("enableCaretBrowsing", SettingsEnableCaretBrowsingPropertyInfo), '("enableDeveloperExtras", SettingsEnableDeveloperExtrasPropertyInfo), '("enableDnsPrefetching", SettingsEnableDnsPrefetchingPropertyInfo), '("enableEncryptedMedia", SettingsEnableEncryptedMediaPropertyInfo), '("enableFrameFlattening", SettingsEnableFrameFlatteningPropertyInfo), '("enableFullscreen", SettingsEnableFullscreenPropertyInfo), '("enableHtml5Database", SettingsEnableHtml5DatabasePropertyInfo), '("enableHtml5LocalStorage", SettingsEnableHtml5LocalStoragePropertyInfo), '("enableHyperlinkAuditing", SettingsEnableHyperlinkAuditingPropertyInfo), '("enableJava", SettingsEnableJavaPropertyInfo), '("enableJavascript", SettingsEnableJavascriptPropertyInfo), '("enableJavascriptMarkup", SettingsEnableJavascriptMarkupPropertyInfo), '("enableMediaCapabilities", SettingsEnableMediaCapabilitiesPropertyInfo), '("enableMediaStream", SettingsEnableMediaStreamPropertyInfo), '("enableMediasource", SettingsEnableMediasourcePropertyInfo), '("enableMockCaptureDevices", SettingsEnableMockCaptureDevicesPropertyInfo), '("enableOfflineWebApplicationCache", SettingsEnableOfflineWebApplicationCachePropertyInfo), '("enablePageCache", SettingsEnablePageCachePropertyInfo), '("enablePlugins", SettingsEnablePluginsPropertyInfo), '("enablePrivateBrowsing", SettingsEnablePrivateBrowsingPropertyInfo), '("enableResizableTextAreas", SettingsEnableResizableTextAreasPropertyInfo), '("enableSiteSpecificQuirks", SettingsEnableSiteSpecificQuirksPropertyInfo), '("enableSmoothScrolling", SettingsEnableSmoothScrollingPropertyInfo), '("enableSpatialNavigation", SettingsEnableSpatialNavigationPropertyInfo), '("enableTabsToLinks", SettingsEnableTabsToLinksPropertyInfo), '("enableWebaudio", SettingsEnableWebaudioPropertyInfo), '("enableWebgl", SettingsEnableWebglPropertyInfo), '("enableWriteConsoleMessagesToStdout", SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo), '("enableXssAuditor", SettingsEnableXssAuditorPropertyInfo), '("fantasyFontFamily", SettingsFantasyFontFamilyPropertyInfo), '("hardwareAccelerationPolicy", SettingsHardwareAccelerationPolicyPropertyInfo), '("javascriptCanAccessClipboard", SettingsJavascriptCanAccessClipboardPropertyInfo), '("javascriptCanOpenWindowsAutomatically", SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo), '("loadIconsIgnoringImageLoadSetting", SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo), '("mediaPlaybackAllowsInline", SettingsMediaPlaybackAllowsInlinePropertyInfo), '("mediaPlaybackRequiresUserGesture", SettingsMediaPlaybackRequiresUserGesturePropertyInfo), '("minimumFontSize", SettingsMinimumFontSizePropertyInfo), '("monospaceFontFamily", SettingsMonospaceFontFamilyPropertyInfo), '("pictographFontFamily", SettingsPictographFontFamilyPropertyInfo), '("printBackgrounds", SettingsPrintBackgroundsPropertyInfo), '("sansSerifFontFamily", SettingsSansSerifFontFamilyPropertyInfo), '("serifFontFamily", SettingsSerifFontFamilyPropertyInfo), '("userAgent", SettingsUserAgentPropertyInfo), '("zoomTextOnly", SettingsZoomTextOnlyPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +settingsAllowFileAccessFromFileUrls :: AttrLabelProxy "allowFileAccessFromFileUrls" +settingsAllowFileAccessFromFileUrls = AttrLabelProxy + +settingsAllowModalDialogs :: AttrLabelProxy "allowModalDialogs" +settingsAllowModalDialogs = AttrLabelProxy + +settingsAllowUniversalAccessFromFileUrls :: AttrLabelProxy "allowUniversalAccessFromFileUrls" +settingsAllowUniversalAccessFromFileUrls = AttrLabelProxy + +settingsAutoLoadImages :: AttrLabelProxy "autoLoadImages" +settingsAutoLoadImages = AttrLabelProxy + +settingsCursiveFontFamily :: AttrLabelProxy "cursiveFontFamily" +settingsCursiveFontFamily = AttrLabelProxy + +settingsDefaultCharset :: AttrLabelProxy "defaultCharset" +settingsDefaultCharset = AttrLabelProxy + +settingsDefaultFontFamily :: AttrLabelProxy "defaultFontFamily" +settingsDefaultFontFamily = AttrLabelProxy + +settingsDefaultFontSize :: AttrLabelProxy "defaultFontSize" +settingsDefaultFontSize = AttrLabelProxy + +settingsDefaultMonospaceFontSize :: AttrLabelProxy "defaultMonospaceFontSize" +settingsDefaultMonospaceFontSize = AttrLabelProxy + +settingsDrawCompositingIndicators :: AttrLabelProxy "drawCompositingIndicators" +settingsDrawCompositingIndicators = AttrLabelProxy + +settingsEnableAccelerated2dCanvas :: AttrLabelProxy "enableAccelerated2dCanvas" +settingsEnableAccelerated2dCanvas = AttrLabelProxy + +settingsEnableBackForwardNavigationGestures :: AttrLabelProxy "enableBackForwardNavigationGestures" +settingsEnableBackForwardNavigationGestures = AttrLabelProxy + +settingsEnableCaretBrowsing :: AttrLabelProxy "enableCaretBrowsing" +settingsEnableCaretBrowsing = AttrLabelProxy + +settingsEnableDeveloperExtras :: AttrLabelProxy "enableDeveloperExtras" +settingsEnableDeveloperExtras = AttrLabelProxy + +settingsEnableDnsPrefetching :: AttrLabelProxy "enableDnsPrefetching" +settingsEnableDnsPrefetching = AttrLabelProxy + +settingsEnableEncryptedMedia :: AttrLabelProxy "enableEncryptedMedia" +settingsEnableEncryptedMedia = AttrLabelProxy + +settingsEnableFrameFlattening :: AttrLabelProxy "enableFrameFlattening" +settingsEnableFrameFlattening = AttrLabelProxy + +settingsEnableFullscreen :: AttrLabelProxy "enableFullscreen" +settingsEnableFullscreen = AttrLabelProxy + +settingsEnableHtml5Database :: AttrLabelProxy "enableHtml5Database" +settingsEnableHtml5Database = AttrLabelProxy + +settingsEnableHtml5LocalStorage :: AttrLabelProxy "enableHtml5LocalStorage" +settingsEnableHtml5LocalStorage = AttrLabelProxy + +settingsEnableHyperlinkAuditing :: AttrLabelProxy "enableHyperlinkAuditing" +settingsEnableHyperlinkAuditing = AttrLabelProxy + +settingsEnableJava :: AttrLabelProxy "enableJava" +settingsEnableJava = AttrLabelProxy + +settingsEnableJavascript :: AttrLabelProxy "enableJavascript" +settingsEnableJavascript = AttrLabelProxy + +settingsEnableJavascriptMarkup :: AttrLabelProxy "enableJavascriptMarkup" +settingsEnableJavascriptMarkup = AttrLabelProxy + +settingsEnableMediaCapabilities :: AttrLabelProxy "enableMediaCapabilities" +settingsEnableMediaCapabilities = AttrLabelProxy + +settingsEnableMediaStream :: AttrLabelProxy "enableMediaStream" +settingsEnableMediaStream = AttrLabelProxy + +settingsEnableMediasource :: AttrLabelProxy "enableMediasource" +settingsEnableMediasource = AttrLabelProxy + +settingsEnableMockCaptureDevices :: AttrLabelProxy "enableMockCaptureDevices" +settingsEnableMockCaptureDevices = AttrLabelProxy + +settingsEnableOfflineWebApplicationCache :: AttrLabelProxy "enableOfflineWebApplicationCache" +settingsEnableOfflineWebApplicationCache = AttrLabelProxy + +settingsEnablePageCache :: AttrLabelProxy "enablePageCache" +settingsEnablePageCache = AttrLabelProxy + +settingsEnablePlugins :: AttrLabelProxy "enablePlugins" +settingsEnablePlugins = AttrLabelProxy + +settingsEnablePrivateBrowsing :: AttrLabelProxy "enablePrivateBrowsing" +settingsEnablePrivateBrowsing = AttrLabelProxy + +settingsEnableResizableTextAreas :: AttrLabelProxy "enableResizableTextAreas" +settingsEnableResizableTextAreas = AttrLabelProxy + +settingsEnableSiteSpecificQuirks :: AttrLabelProxy "enableSiteSpecificQuirks" +settingsEnableSiteSpecificQuirks = AttrLabelProxy + +settingsEnableSmoothScrolling :: AttrLabelProxy "enableSmoothScrolling" +settingsEnableSmoothScrolling = AttrLabelProxy + +settingsEnableSpatialNavigation :: AttrLabelProxy "enableSpatialNavigation" +settingsEnableSpatialNavigation = AttrLabelProxy + +settingsEnableTabsToLinks :: AttrLabelProxy "enableTabsToLinks" +settingsEnableTabsToLinks = AttrLabelProxy + +settingsEnableWebaudio :: AttrLabelProxy "enableWebaudio" +settingsEnableWebaudio = AttrLabelProxy + +settingsEnableWebgl :: AttrLabelProxy "enableWebgl" +settingsEnableWebgl = AttrLabelProxy + +settingsEnableWriteConsoleMessagesToStdout :: AttrLabelProxy "enableWriteConsoleMessagesToStdout" +settingsEnableWriteConsoleMessagesToStdout = AttrLabelProxy + +settingsEnableXssAuditor :: AttrLabelProxy "enableXssAuditor" +settingsEnableXssAuditor = AttrLabelProxy + +settingsFantasyFontFamily :: AttrLabelProxy "fantasyFontFamily" +settingsFantasyFontFamily = AttrLabelProxy + +settingsHardwareAccelerationPolicy :: AttrLabelProxy "hardwareAccelerationPolicy" +settingsHardwareAccelerationPolicy = AttrLabelProxy + +settingsJavascriptCanAccessClipboard :: AttrLabelProxy "javascriptCanAccessClipboard" +settingsJavascriptCanAccessClipboard = AttrLabelProxy + +settingsJavascriptCanOpenWindowsAutomatically :: AttrLabelProxy "javascriptCanOpenWindowsAutomatically" +settingsJavascriptCanOpenWindowsAutomatically = AttrLabelProxy + +settingsLoadIconsIgnoringImageLoadSetting :: AttrLabelProxy "loadIconsIgnoringImageLoadSetting" +settingsLoadIconsIgnoringImageLoadSetting = AttrLabelProxy + +settingsMediaPlaybackAllowsInline :: AttrLabelProxy "mediaPlaybackAllowsInline" +settingsMediaPlaybackAllowsInline = AttrLabelProxy + +settingsMediaPlaybackRequiresUserGesture :: AttrLabelProxy "mediaPlaybackRequiresUserGesture" +settingsMediaPlaybackRequiresUserGesture = AttrLabelProxy + +settingsMinimumFontSize :: AttrLabelProxy "minimumFontSize" +settingsMinimumFontSize = AttrLabelProxy + +settingsMonospaceFontFamily :: AttrLabelProxy "monospaceFontFamily" +settingsMonospaceFontFamily = AttrLabelProxy + +settingsPictographFontFamily :: AttrLabelProxy "pictographFontFamily" +settingsPictographFontFamily = AttrLabelProxy + +settingsPrintBackgrounds :: AttrLabelProxy "printBackgrounds" +settingsPrintBackgrounds = AttrLabelProxy + +settingsSansSerifFontFamily :: AttrLabelProxy "sansSerifFontFamily" +settingsSansSerifFontFamily = AttrLabelProxy + +settingsSerifFontFamily :: AttrLabelProxy "serifFontFamily" +settingsSerifFontFamily = AttrLabelProxy + +settingsUserAgent :: AttrLabelProxy "userAgent" +settingsUserAgent = AttrLabelProxy + +settingsZoomTextOnly :: AttrLabelProxy "zoomTextOnly" +settingsZoomTextOnly = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Settings = SettingsSignalList +type SettingsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Settings::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Settings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_new" webkit_settings_new :: + IO (Ptr Settings) + +{- | +Creates a new 'GI.WebKit2.Objects.Settings.Settings' instance with default values. It must +be manually attached to a 'GI.WebKit2.Objects.WebView.WebView'. +See also @/webkit_settings_new_with_settings()/@. +-} +settingsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Settings + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.Settings.Settings' instance. -} +settingsNew = liftIO $ do + result <- webkit_settings_new + checkUnexpectedReturnNULL "settingsNew" result + result' <- (wrapObject Settings) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Settings::get_allow_file_access_from_file_urls +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_allow_file_access_from_file_urls" webkit_settings_get_allow_file_access_from_file_urls :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/allow-file-access-from-file-urls/@ property. + +/Since: 2.10/ +-} +settingsGetAllowFileAccessFromFileUrls :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If file access from file URLs is allowed or 'False' otherwise. -} +settingsGetAllowFileAccessFromFileUrls settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_allow_file_access_from_file_urls settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetAllowFileAccessFromFileUrlsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetAllowFileAccessFromFileUrlsMethodInfo a signature where + overloadedMethod _ = settingsGetAllowFileAccessFromFileUrls + +#endif + +-- method Settings::get_allow_modal_dialogs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_allow_modal_dialogs" webkit_settings_get_allow_modal_dialogs :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/allow-modal-dialogs/@ property. +-} +settingsGetAllowModalDialogs :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if it\'s allowed to create and run modal dialogs or 'False' otherwise. -} +settingsGetAllowModalDialogs settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_allow_modal_dialogs settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetAllowModalDialogsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetAllowModalDialogsMethodInfo a signature where + overloadedMethod _ = settingsGetAllowModalDialogs + +#endif + +-- method Settings::get_allow_universal_access_from_file_urls +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_allow_universal_access_from_file_urls" webkit_settings_get_allow_universal_access_from_file_urls :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/allow-universal-access-from-file-urls/@ property. + +/Since: 2.14/ +-} +settingsGetAllowUniversalAccessFromFileUrls :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If universal access from file URLs is allowed or 'False' otherwise. -} +settingsGetAllowUniversalAccessFromFileUrls settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_allow_universal_access_from_file_urls settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetAllowUniversalAccessFromFileUrlsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetAllowUniversalAccessFromFileUrlsMethodInfo a signature where + overloadedMethod _ = settingsGetAllowUniversalAccessFromFileUrls + +#endif + +-- method Settings::get_auto_load_images +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_auto_load_images" webkit_settings_get_auto_load_images :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/auto-load-images/@ property. +-} +settingsGetAutoLoadImages :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If auto loading of images is enabled or 'False' otherwise. -} +settingsGetAutoLoadImages settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_auto_load_images settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetAutoLoadImagesMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetAutoLoadImagesMethodInfo a signature where + overloadedMethod _ = settingsGetAutoLoadImages + +#endif + +-- method Settings::get_cursive_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_cursive_font_family" webkit_settings_get_cursive_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/cursive-font-family/@ property. +-} +settingsGetCursiveFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The default font family used to display content marked with cursive font. -} +settingsGetCursiveFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_cursive_font_family settings' + checkUnexpectedReturnNULL "settingsGetCursiveFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetCursiveFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetCursiveFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetCursiveFontFamily + +#endif + +-- method Settings::get_default_charset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_default_charset" webkit_settings_get_default_charset :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/default-charset/@ property. +-} +settingsGetDefaultCharset :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ Default charset. -} +settingsGetDefaultCharset settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_default_charset settings' + checkUnexpectedReturnNULL "settingsGetDefaultCharset" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetDefaultCharsetMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetDefaultCharsetMethodInfo a signature where + overloadedMethod _ = settingsGetDefaultCharset + +#endif + +-- method Settings::get_default_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_settings_get_default_font_family" webkit_settings_get_default_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +settingsGetDefaultFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -> m T.Text +settingsGetDefaultFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_default_font_family settings' + checkUnexpectedReturnNULL "settingsGetDefaultFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetDefaultFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetDefaultFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetDefaultFontFamily + +#endif + +-- method Settings::get_default_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_default_font_size" webkit_settings_get_default_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO Word32 + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/default-font-size/@ property. +-} +settingsGetDefaultFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Word32 + {- ^ __Returns:__ The default font size, in pixels. -} +settingsGetDefaultFontSize settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_default_font_size settings' + touchManagedPtr settings + return result + +#if ENABLE_OVERLOADING +data SettingsGetDefaultFontSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetDefaultFontSizeMethodInfo a signature where + overloadedMethod _ = settingsGetDefaultFontSize + +#endif + +-- method Settings::get_default_monospace_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_default_monospace_font_size" webkit_settings_get_default_monospace_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO Word32 + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/default-monospace-font-size/@ property. +-} +settingsGetDefaultMonospaceFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Word32 + {- ^ __Returns:__ Default monospace font size, in pixels. -} +settingsGetDefaultMonospaceFontSize settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_default_monospace_font_size settings' + touchManagedPtr settings + return result + +#if ENABLE_OVERLOADING +data SettingsGetDefaultMonospaceFontSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetDefaultMonospaceFontSizeMethodInfo a signature where + overloadedMethod _ = settingsGetDefaultMonospaceFontSize + +#endif + +-- method Settings::get_draw_compositing_indicators +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_draw_compositing_indicators" webkit_settings_get_draw_compositing_indicators :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/draw-compositing-indicators/@ property. +-} +settingsGetDrawCompositingIndicators :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If compositing borders are drawn or 'False' otherwise. -} +settingsGetDrawCompositingIndicators settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_draw_compositing_indicators settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetDrawCompositingIndicatorsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetDrawCompositingIndicatorsMethodInfo a signature where + overloadedMethod _ = settingsGetDrawCompositingIndicators + +#endif + +-- method Settings::get_enable_accelerated_2d_canvas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_accelerated_2d_canvas" webkit_settings_get_enable_accelerated_2d_canvas :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-accelerated-2d-canvas/@ property. + +/Since: 2.2/ +-} +settingsGetEnableAccelerated2dCanvas :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if accelerated 2D canvas is enabled or 'False' otherwise. -} +settingsGetEnableAccelerated2dCanvas settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_accelerated_2d_canvas settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableAccelerated2dCanvasMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableAccelerated2dCanvasMethodInfo a signature where + overloadedMethod _ = settingsGetEnableAccelerated2dCanvas + +#endif + +-- method Settings::get_enable_back_forward_navigation_gestures +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_back_forward_navigation_gestures" webkit_settings_get_enable_back_forward_navigation_gestures :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-back-forward-navigation-gestures/@ property. + +/Since: 2.24/ +-} +settingsGetEnableBackForwardNavigationGestures :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if horizontal swipe gesture will trigger back-forward navigaiton or 'False' otherwise. -} +settingsGetEnableBackForwardNavigationGestures settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_back_forward_navigation_gestures settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableBackForwardNavigationGesturesMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableBackForwardNavigationGesturesMethodInfo a signature where + overloadedMethod _ = settingsGetEnableBackForwardNavigationGestures + +#endif + +-- method Settings::get_enable_caret_browsing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_caret_browsing" webkit_settings_get_enable_caret_browsing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-caret-browsing/@ property. +-} +settingsGetEnableCaretBrowsing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If caret browsing is enabled or 'False' otherwise. -} +settingsGetEnableCaretBrowsing settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_caret_browsing settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableCaretBrowsingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableCaretBrowsingMethodInfo a signature where + overloadedMethod _ = settingsGetEnableCaretBrowsing + +#endif + +-- method Settings::get_enable_developer_extras +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_developer_extras" webkit_settings_get_enable_developer_extras :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-developer-extras/@ property. +-} +settingsGetEnableDeveloperExtras :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If developer extras is enabled or 'False' otherwise. -} +settingsGetEnableDeveloperExtras settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_developer_extras settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableDeveloperExtrasMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableDeveloperExtrasMethodInfo a signature where + overloadedMethod _ = settingsGetEnableDeveloperExtras + +#endif + +-- method Settings::get_enable_dns_prefetching +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_dns_prefetching" webkit_settings_get_enable_dns_prefetching :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-dns-prefetching/@ property. +-} +settingsGetEnableDnsPrefetching :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If DNS prefetching is enabled or 'False' otherwise. -} +settingsGetEnableDnsPrefetching settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_dns_prefetching settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableDnsPrefetchingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableDnsPrefetchingMethodInfo a signature where + overloadedMethod _ = settingsGetEnableDnsPrefetching + +#endif + +-- method Settings::get_enable_encrypted_media +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_encrypted_media" webkit_settings_get_enable_encrypted_media :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-encrypted-media/@ property. + +/Since: 2.20/ +-} +settingsGetEnableEncryptedMedia :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if EncryptedMedia support is enabled or 'False' otherwise. -} +settingsGetEnableEncryptedMedia settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_encrypted_media settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableEncryptedMediaMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableEncryptedMediaMethodInfo a signature where + overloadedMethod _ = settingsGetEnableEncryptedMedia + +#endif + +-- method Settings::get_enable_frame_flattening +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_frame_flattening" webkit_settings_get_enable_frame_flattening :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-frame-flattening/@ property. +-} +settingsGetEnableFrameFlattening :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If frame flattening is enabled or 'False' otherwise. -} +settingsGetEnableFrameFlattening settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_frame_flattening settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableFrameFlatteningMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableFrameFlatteningMethodInfo a signature where + overloadedMethod _ = settingsGetEnableFrameFlattening + +#endif + +-- method Settings::get_enable_fullscreen +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_fullscreen" webkit_settings_get_enable_fullscreen :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-fullscreen/@ property. +-} +settingsGetEnableFullscreen :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If fullscreen support is enabled or 'False' otherwise. -} +settingsGetEnableFullscreen settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_fullscreen settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableFullscreenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableFullscreenMethodInfo a signature where + overloadedMethod _ = settingsGetEnableFullscreen + +#endif + +-- method Settings::get_enable_html5_database +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_html5_database" webkit_settings_get_enable_html5_database :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-html5-database/@ property. +-} +settingsGetEnableHtml5Database :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If HTML5 database support is enabled or 'False' otherwise. -} +settingsGetEnableHtml5Database settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_html5_database settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableHtml5DatabaseMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableHtml5DatabaseMethodInfo a signature where + overloadedMethod _ = settingsGetEnableHtml5Database + +#endif + +-- method Settings::get_enable_html5_local_storage +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_html5_local_storage" webkit_settings_get_enable_html5_local_storage :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-html5-local-storage/@ property. +-} +settingsGetEnableHtml5LocalStorage :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If HTML5 local storage support is enabled or 'False' otherwise. -} +settingsGetEnableHtml5LocalStorage settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_html5_local_storage settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableHtml5LocalStorageMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableHtml5LocalStorageMethodInfo a signature where + overloadedMethod _ = settingsGetEnableHtml5LocalStorage + +#endif + +-- method Settings::get_enable_hyperlink_auditing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_hyperlink_auditing" webkit_settings_get_enable_hyperlink_auditing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-hyperlink-auditing/@ property. +-} +settingsGetEnableHyperlinkAuditing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If hyper link auditing is enabled or 'False' otherwise. -} +settingsGetEnableHyperlinkAuditing settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_hyperlink_auditing settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableHyperlinkAuditingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableHyperlinkAuditingMethodInfo a signature where + overloadedMethod _ = settingsGetEnableHyperlinkAuditing + +#endif + +-- method Settings::get_enable_java +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_java" webkit_settings_get_enable_java :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-java/@ property. +-} +settingsGetEnableJava :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If Java is enabled or 'False' otherwise. -} +settingsGetEnableJava settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_java settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableJavaMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableJavaMethodInfo a signature where + overloadedMethod _ = settingsGetEnableJava + +#endif + +-- method Settings::get_enable_javascript +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_javascript" webkit_settings_get_enable_javascript :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-javascript/@ property. +-} +settingsGetEnableJavascript :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If JavaScript is enabled or 'False' otherwise. -} +settingsGetEnableJavascript settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_javascript settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableJavascriptMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableJavascriptMethodInfo a signature where + overloadedMethod _ = settingsGetEnableJavascript + +#endif + +-- method Settings::get_enable_javascript_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_javascript_markup" webkit_settings_get_enable_javascript_markup :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-javascript-markup/@ property. + +/Since: 2.24/ +-} +settingsGetEnableJavascriptMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if JavaScript markup is enabled or 'False' otherwise. -} +settingsGetEnableJavascriptMarkup settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_javascript_markup settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableJavascriptMarkupMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableJavascriptMarkupMethodInfo a signature where + overloadedMethod _ = settingsGetEnableJavascriptMarkup + +#endif + +-- method Settings::get_enable_media_capabilities +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_media_capabilities" webkit_settings_get_enable_media_capabilities :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-media-capabilities/@ property. + +/Since: 2.22/ +-} +settingsGetEnableMediaCapabilities :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if MediaCapabilities support is enabled or 'False' otherwise. -} +settingsGetEnableMediaCapabilities settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_media_capabilities settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableMediaCapabilitiesMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableMediaCapabilitiesMethodInfo a signature where + overloadedMethod _ = settingsGetEnableMediaCapabilities + +#endif + +-- method Settings::get_enable_media_stream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_media_stream" webkit_settings_get_enable_media_stream :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-media-stream/@ property. + +/Since: 2.4/ +-} +settingsGetEnableMediaStream :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If mediastream support is enabled or 'False' otherwise. -} +settingsGetEnableMediaStream settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_media_stream settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableMediaStreamMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableMediaStreamMethodInfo a signature where + overloadedMethod _ = settingsGetEnableMediaStream + +#endif + +-- method Settings::get_enable_mediasource +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_mediasource" webkit_settings_get_enable_mediasource :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-mediasource/@ property. + +/Since: 2.4/ +-} +settingsGetEnableMediasource :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If MediaSource support is enabled or 'False' otherwise. -} +settingsGetEnableMediasource settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_mediasource settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableMediasourceMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableMediasourceMethodInfo a signature where + overloadedMethod _ = settingsGetEnableMediasource + +#endif + +-- method Settings::get_enable_mock_capture_devices +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_mock_capture_devices" webkit_settings_get_enable_mock_capture_devices :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-mock-capture-devices/@ property. + +/Since: 2.24/ +-} +settingsGetEnableMockCaptureDevices :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If mock capture devices is enabled or 'False' otherwise. -} +settingsGetEnableMockCaptureDevices settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_mock_capture_devices settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableMockCaptureDevicesMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableMockCaptureDevicesMethodInfo a signature where + overloadedMethod _ = settingsGetEnableMockCaptureDevices + +#endif + +-- method Settings::get_enable_offline_web_application_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_offline_web_application_cache" webkit_settings_get_enable_offline_web_application_cache :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-offline-web-application-cache/@ property. +-} +settingsGetEnableOfflineWebApplicationCache :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If HTML5 offline web application cache support is enabled or 'False' otherwise. -} +settingsGetEnableOfflineWebApplicationCache settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_offline_web_application_cache settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableOfflineWebApplicationCacheMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableOfflineWebApplicationCacheMethodInfo a signature where + overloadedMethod _ = settingsGetEnableOfflineWebApplicationCache + +#endif + +-- method Settings::get_enable_page_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_page_cache" webkit_settings_get_enable_page_cache :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-page-cache/@ property. +-} +settingsGetEnablePageCache :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if page cache enabled or 'False' otherwise. -} +settingsGetEnablePageCache settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_page_cache settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnablePageCacheMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnablePageCacheMethodInfo a signature where + overloadedMethod _ = settingsGetEnablePageCache + +#endif + +-- method Settings::get_enable_plugins +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_plugins" webkit_settings_get_enable_plugins :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-plugins/@ property. +-} +settingsGetEnablePlugins :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If plugins are enabled or 'False' otherwise. -} +settingsGetEnablePlugins settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_plugins settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnablePluginsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnablePluginsMethodInfo a signature where + overloadedMethod _ = settingsGetEnablePlugins + +#endif + +-- method Settings::get_enable_private_browsing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_private_browsing" webkit_settings_get_enable_private_browsing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{-# DEPRECATED settingsGetEnablePrivateBrowsing ["(Since version 2.16.)","Use 'GI.WebKit2.Objects.WebView.WebView':@/is-ephemeral/@ or 'GI.WebKit2.Objects.WebContext.WebContext':@/is-ephemeral/@ instead."] #-} +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-private-browsing/@ property. +-} +settingsGetEnablePrivateBrowsing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If private browsing is enabled or 'False' otherwise. -} +settingsGetEnablePrivateBrowsing settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_private_browsing settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnablePrivateBrowsingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnablePrivateBrowsingMethodInfo a signature where + overloadedMethod _ = settingsGetEnablePrivateBrowsing + +#endif + +-- method Settings::get_enable_resizable_text_areas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_resizable_text_areas" webkit_settings_get_enable_resizable_text_areas :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-resizable-text-areas/@ property. +-} +settingsGetEnableResizableTextAreas :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If text areas can be resized or 'False' otherwise. -} +settingsGetEnableResizableTextAreas settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_resizable_text_areas settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableResizableTextAreasMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableResizableTextAreasMethodInfo a signature where + overloadedMethod _ = settingsGetEnableResizableTextAreas + +#endif + +-- method Settings::get_enable_site_specific_quirks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_site_specific_quirks" webkit_settings_get_enable_site_specific_quirks :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-site-specific-quirks/@ property. +-} +settingsGetEnableSiteSpecificQuirks :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if site specific quirks are enabled or 'False' otherwise. -} +settingsGetEnableSiteSpecificQuirks settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_site_specific_quirks settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableSiteSpecificQuirksMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableSiteSpecificQuirksMethodInfo a signature where + overloadedMethod _ = settingsGetEnableSiteSpecificQuirks + +#endif + +-- method Settings::get_enable_smooth_scrolling +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_smooth_scrolling" webkit_settings_get_enable_smooth_scrolling :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-smooth-scrolling/@ property. +-} +settingsGetEnableSmoothScrolling :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if smooth scrolling is enabled or 'False' otherwise. -} +settingsGetEnableSmoothScrolling settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_smooth_scrolling settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableSmoothScrollingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableSmoothScrollingMethodInfo a signature where + overloadedMethod _ = settingsGetEnableSmoothScrolling + +#endif + +-- method Settings::get_enable_spatial_navigation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_spatial_navigation" webkit_settings_get_enable_spatial_navigation :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-spatial-navigation/@ property. + +/Since: 2.2/ +-} +settingsGetEnableSpatialNavigation :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If HTML5 spatial navigation support is enabled or 'False' otherwise. -} +settingsGetEnableSpatialNavigation settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_spatial_navigation settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableSpatialNavigationMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableSpatialNavigationMethodInfo a signature where + overloadedMethod _ = settingsGetEnableSpatialNavigation + +#endif + +-- method Settings::get_enable_tabs_to_links +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_tabs_to_links" webkit_settings_get_enable_tabs_to_links :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-tabs-to-links/@ property. +-} +settingsGetEnableTabsToLinks :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If tabs to link is enabled or 'False' otherwise. -} +settingsGetEnableTabsToLinks settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_tabs_to_links settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableTabsToLinksMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableTabsToLinksMethodInfo a signature where + overloadedMethod _ = settingsGetEnableTabsToLinks + +#endif + +-- method Settings::get_enable_webaudio +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_webaudio" webkit_settings_get_enable_webaudio :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-webaudio/@ property. +-} +settingsGetEnableWebaudio :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If webaudio support is enabled or 'False' otherwise. -} +settingsGetEnableWebaudio settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_webaudio settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableWebaudioMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableWebaudioMethodInfo a signature where + overloadedMethod _ = settingsGetEnableWebaudio + +#endif + +-- method Settings::get_enable_webgl +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_webgl" webkit_settings_get_enable_webgl :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-webgl/@ property. +-} +settingsGetEnableWebgl :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If WebGL support is enabled or 'False' otherwise. -} +settingsGetEnableWebgl settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_webgl settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableWebglMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableWebglMethodInfo a signature where + overloadedMethod _ = settingsGetEnableWebgl + +#endif + +-- method Settings::get_enable_write_console_messages_to_stdout +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_write_console_messages_to_stdout" webkit_settings_get_enable_write_console_messages_to_stdout :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-write-console-messages-to-stdout/@ property. + +/Since: 2.2/ +-} +settingsGetEnableWriteConsoleMessagesToStdout :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' if writing console messages to stdout is enabled or 'False' +otherwise. -} +settingsGetEnableWriteConsoleMessagesToStdout settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_write_console_messages_to_stdout settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableWriteConsoleMessagesToStdoutMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableWriteConsoleMessagesToStdoutMethodInfo a signature where + overloadedMethod _ = settingsGetEnableWriteConsoleMessagesToStdout + +#endif + +-- method Settings::get_enable_xss_auditor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_enable_xss_auditor" webkit_settings_get_enable_xss_auditor :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/enable-xss-auditor/@ property. +-} +settingsGetEnableXssAuditor :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If XSS auditing is enabled or 'False' otherwise. -} +settingsGetEnableXssAuditor settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_enable_xss_auditor settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetEnableXssAuditorMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetEnableXssAuditorMethodInfo a signature where + overloadedMethod _ = settingsGetEnableXssAuditor + +#endif + +-- method Settings::get_fantasy_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_fantasy_font_family" webkit_settings_get_fantasy_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/fantasy-font-family/@ property. +-} +settingsGetFantasyFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The default font family used to display content marked with fantasy font. -} +settingsGetFantasyFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_fantasy_font_family settings' + checkUnexpectedReturnNULL "settingsGetFantasyFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetFantasyFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetFantasyFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetFantasyFontFamily + +#endif + +-- method Settings::get_hardware_acceleration_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "HardwareAccelerationPolicy"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_hardware_acceleration_policy" webkit_settings_get_hardware_acceleration_policy :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CUInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/hardware-acceleration-policy/@ property. + +/Since: 2.16/ +-} +settingsGetHardwareAccelerationPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m WebKit2.Enums.HardwareAccelerationPolicy + {- ^ __Returns:__ a 'GI.WebKit2.Enums.HardwareAccelerationPolicy' -} +settingsGetHardwareAccelerationPolicy settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_hardware_acceleration_policy settings' + let result' = (toEnum . fromIntegral) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetHardwareAccelerationPolicyMethodInfo +instance (signature ~ (m WebKit2.Enums.HardwareAccelerationPolicy), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetHardwareAccelerationPolicyMethodInfo a signature where + overloadedMethod _ = settingsGetHardwareAccelerationPolicy + +#endif + +-- method Settings::get_javascript_can_access_clipboard +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_javascript_can_access_clipboard" webkit_settings_get_javascript_can_access_clipboard :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/javascript-can-access-clipboard/@ property. +-} +settingsGetJavascriptCanAccessClipboard :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If javascript-can-access-clipboard is enabled or 'False' otherwise. -} +settingsGetJavascriptCanAccessClipboard settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_javascript_can_access_clipboard settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetJavascriptCanAccessClipboardMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetJavascriptCanAccessClipboardMethodInfo a signature where + overloadedMethod _ = settingsGetJavascriptCanAccessClipboard + +#endif + +-- method Settings::get_javascript_can_open_windows_automatically +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_javascript_can_open_windows_automatically" webkit_settings_get_javascript_can_open_windows_automatically :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/javascript-can-open-windows-automatically/@ property. +-} +settingsGetJavascriptCanOpenWindowsAutomatically :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If JavaScript can open window automatically or 'False' otherwise. -} +settingsGetJavascriptCanOpenWindowsAutomatically settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_javascript_can_open_windows_automatically settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetJavascriptCanOpenWindowsAutomaticallyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetJavascriptCanOpenWindowsAutomaticallyMethodInfo a signature where + overloadedMethod _ = settingsGetJavascriptCanOpenWindowsAutomatically + +#endif + +-- method Settings::get_load_icons_ignoring_image_load_setting +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_load_icons_ignoring_image_load_setting" webkit_settings_get_load_icons_ignoring_image_load_setting :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/load-icons-ignoring-image-load-setting/@ property. +-} +settingsGetLoadIconsIgnoringImageLoadSetting :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If site icon can be loaded irrespective of image loading preference or 'False' otherwise. -} +settingsGetLoadIconsIgnoringImageLoadSetting settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_load_icons_ignoring_image_load_setting settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetLoadIconsIgnoringImageLoadSettingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetLoadIconsIgnoringImageLoadSettingMethodInfo a signature where + overloadedMethod _ = settingsGetLoadIconsIgnoringImageLoadSetting + +#endif + +-- method Settings::get_media_playback_allows_inline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_media_playback_allows_inline" webkit_settings_get_media_playback_allows_inline :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/media-playback-allows-inline/@ property. +-} +settingsGetMediaPlaybackAllowsInline :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If inline playback is allowed for media + or 'False' if only fullscreen playback is allowed. -} +settingsGetMediaPlaybackAllowsInline settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_media_playback_allows_inline settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetMediaPlaybackAllowsInlineMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetMediaPlaybackAllowsInlineMethodInfo a signature where + overloadedMethod _ = settingsGetMediaPlaybackAllowsInline + +#endif + +-- method Settings::get_media_playback_requires_user_gesture +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_media_playback_requires_user_gesture" webkit_settings_get_media_playback_requires_user_gesture :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/media-playback-requires-user-gesture/@ property. +-} +settingsGetMediaPlaybackRequiresUserGesture :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If an user gesture is needed to play or load media + or 'False' if no user gesture is needed. -} +settingsGetMediaPlaybackRequiresUserGesture settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_media_playback_requires_user_gesture settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetMediaPlaybackRequiresUserGestureMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetMediaPlaybackRequiresUserGestureMethodInfo a signature where + overloadedMethod _ = settingsGetMediaPlaybackRequiresUserGesture + +#endif + +-- method Settings::get_minimum_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_minimum_font_size" webkit_settings_get_minimum_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO Word32 + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/minimum-font-size/@ property. +-} +settingsGetMinimumFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Word32 + {- ^ __Returns:__ Minimum font size, in pixels. -} +settingsGetMinimumFontSize settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_minimum_font_size settings' + touchManagedPtr settings + return result + +#if ENABLE_OVERLOADING +data SettingsGetMinimumFontSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetMinimumFontSizeMethodInfo a signature where + overloadedMethod _ = settingsGetMinimumFontSize + +#endif + +-- method Settings::get_monospace_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_monospace_font_family" webkit_settings_get_monospace_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/monospace-font-family/@ property. +-} +settingsGetMonospaceFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ Default font family used to display content marked with monospace font. -} +settingsGetMonospaceFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_monospace_font_family settings' + checkUnexpectedReturnNULL "settingsGetMonospaceFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetMonospaceFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetMonospaceFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetMonospaceFontFamily + +#endif + +-- method Settings::get_pictograph_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_pictograph_font_family" webkit_settings_get_pictograph_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/pictograph-font-family/@ property. +-} +settingsGetPictographFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The default font family used to display content marked with pictograph font. -} +settingsGetPictographFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_pictograph_font_family settings' + checkUnexpectedReturnNULL "settingsGetPictographFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetPictographFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetPictographFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetPictographFontFamily + +#endif + +-- method Settings::get_print_backgrounds +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_print_backgrounds" webkit_settings_get_print_backgrounds :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/print-backgrounds/@ property. +-} +settingsGetPrintBackgrounds :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If background images should be printed or 'False' otherwise. -} +settingsGetPrintBackgrounds settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_print_backgrounds settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetPrintBackgroundsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetPrintBackgroundsMethodInfo a signature where + overloadedMethod _ = settingsGetPrintBackgrounds + +#endif + +-- method Settings::get_sans_serif_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_sans_serif_font_family" webkit_settings_get_sans_serif_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/sans-serif-font-family/@ property. +-} +settingsGetSansSerifFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The default font family used to display content marked with sans-serif font. -} +settingsGetSansSerifFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_sans_serif_font_family settings' + checkUnexpectedReturnNULL "settingsGetSansSerifFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetSansSerifFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetSansSerifFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetSansSerifFontFamily + +#endif + +-- method Settings::get_serif_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_serif_font_family" webkit_settings_get_serif_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings':@/serif-font-family/@ property. +-} +settingsGetSerifFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The default font family used to display content marked with serif font. -} +settingsGetSerifFontFamily settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_serif_font_family settings' + checkUnexpectedReturnNULL "settingsGetSerifFontFamily" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetSerifFontFamilyMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetSerifFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsGetSerifFontFamily + +#endif + +-- method Settings::get_user_agent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_settings_get_user_agent" webkit_settings_get_user_agent :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/user-agent/@ property. +-} +settingsGetUserAgent :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m T.Text + {- ^ __Returns:__ The current value of the user-agent property. -} +settingsGetUserAgent settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_user_agent settings' + checkUnexpectedReturnNULL "settingsGetUserAgent" result + result' <- cstringToText result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetUserAgentMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetUserAgentMethodInfo a signature where + overloadedMethod _ = settingsGetUserAgent + +#endif + +-- method Settings::get_zoom_text_only +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_get_zoom_text_only" webkit_settings_get_zoom_text_only :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO CInt + +{- | +Get the 'GI.WebKit2.Objects.Settings.Settings':@/zoom-text-only/@ property. +-} +settingsGetZoomTextOnly :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m Bool + {- ^ __Returns:__ 'True' If zoom level of the view should only affect the text + or 'False' if all view contents should be scaled. -} +settingsGetZoomTextOnly settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_settings_get_zoom_text_only settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SettingsGetZoomTextOnlyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSettings a) => O.MethodInfo SettingsGetZoomTextOnlyMethodInfo a signature where + overloadedMethod _ = settingsGetZoomTextOnly + +#endif + +-- method Settings::set_allow_file_access_from_file_urls +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_allow_file_access_from_file_urls" webkit_settings_set_allow_file_access_from_file_urls :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- allowed : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/allow-file-access-from-file-urls/@ property. + +/Since: 2.10/ +-} +settingsSetAllowFileAccessFromFileUrls :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@allowed@/: Value to be set -} + -> m () +settingsSetAllowFileAccessFromFileUrls settings allowed = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let allowed' = (fromIntegral . fromEnum) allowed + webkit_settings_set_allow_file_access_from_file_urls settings' allowed' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetAllowFileAccessFromFileUrlsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetAllowFileAccessFromFileUrlsMethodInfo a signature where + overloadedMethod _ = settingsSetAllowFileAccessFromFileUrls + +#endif + +-- method Settings::set_allow_modal_dialogs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_allow_modal_dialogs" webkit_settings_set_allow_modal_dialogs :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- allowed : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/allow-modal-dialogs/@ property. +-} +settingsSetAllowModalDialogs :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@allowed@/: Value to be set -} + -> m () +settingsSetAllowModalDialogs settings allowed = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let allowed' = (fromIntegral . fromEnum) allowed + webkit_settings_set_allow_modal_dialogs settings' allowed' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetAllowModalDialogsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetAllowModalDialogsMethodInfo a signature where + overloadedMethod _ = settingsSetAllowModalDialogs + +#endif + +-- method Settings::set_allow_universal_access_from_file_urls +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_allow_universal_access_from_file_urls" webkit_settings_set_allow_universal_access_from_file_urls :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- allowed : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/allow-universal-access-from-file-urls/@ property. + +/Since: 2.14/ +-} +settingsSetAllowUniversalAccessFromFileUrls :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@allowed@/: Value to be set -} + -> m () +settingsSetAllowUniversalAccessFromFileUrls settings allowed = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let allowed' = (fromIntegral . fromEnum) allowed + webkit_settings_set_allow_universal_access_from_file_urls settings' allowed' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetAllowUniversalAccessFromFileUrlsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetAllowUniversalAccessFromFileUrlsMethodInfo a signature where + overloadedMethod _ = settingsSetAllowUniversalAccessFromFileUrls + +#endif + +-- method Settings::set_auto_load_images +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_auto_load_images" webkit_settings_set_auto_load_images :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/auto-load-images/@ property. +-} +settingsSetAutoLoadImages :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetAutoLoadImages settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_auto_load_images settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetAutoLoadImagesMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetAutoLoadImagesMethodInfo a signature where + overloadedMethod _ = settingsSetAutoLoadImages + +#endif + +-- method Settings::set_cursive_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursive_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default cursive font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_cursive_font_family" webkit_settings_set_cursive_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- cursive_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/cursive-font-family/@ property. +-} +settingsSetCursiveFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@cursiveFontFamily@/: the new default cursive font family -} + -> m () +settingsSetCursiveFontFamily settings cursiveFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + cursiveFontFamily' <- textToCString cursiveFontFamily + webkit_settings_set_cursive_font_family settings' cursiveFontFamily' + touchManagedPtr settings + freeMem cursiveFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetCursiveFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetCursiveFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetCursiveFontFamily + +#endif + +-- method Settings::set_default_charset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default charset to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_default_charset" webkit_settings_set_default_charset :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- default_charset : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/default-charset/@ property. +-} +settingsSetDefaultCharset :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@defaultCharset@/: default charset to be set -} + -> m () +settingsSetDefaultCharset settings defaultCharset = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + defaultCharset' <- textToCString defaultCharset + webkit_settings_set_default_charset settings' defaultCharset' + touchManagedPtr settings + freeMem defaultCharset' + return () + +#if ENABLE_OVERLOADING +data SettingsSetDefaultCharsetMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetDefaultCharsetMethodInfo a signature where + overloadedMethod _ = settingsSetDefaultCharset + +#endif + +-- method Settings::set_default_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_default_font_family" webkit_settings_set_default_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- default_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/default-font-family/@ property. +-} +settingsSetDefaultFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@defaultFontFamily@/: the new default font family -} + -> m () +settingsSetDefaultFontFamily settings defaultFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + defaultFontFamily' <- textToCString defaultFontFamily + webkit_settings_set_default_font_family settings' defaultFontFamily' + touchManagedPtr settings + freeMem defaultFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetDefaultFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetDefaultFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetDefaultFontFamily + +#endif + +-- method Settings::set_default_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default font size to be set in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_default_font_size" webkit_settings_set_default_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + Word32 -> -- font_size : TBasicType TUInt32 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/default-font-size/@ property. +-} +settingsSetDefaultFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Word32 + {- ^ /@fontSize@/: default font size to be set in pixels -} + -> m () +settingsSetDefaultFontSize settings fontSize = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + webkit_settings_set_default_font_size settings' fontSize + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetDefaultFontSizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetDefaultFontSizeMethodInfo a signature where + overloadedMethod _ = settingsSetDefaultFontSize + +#endif + +-- method Settings::set_default_monospace_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "default monospace font size to be set in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_default_monospace_font_size" webkit_settings_set_default_monospace_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + Word32 -> -- font_size : TBasicType TUInt32 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/default-monospace-font-size/@ property. +-} +settingsSetDefaultMonospaceFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Word32 + {- ^ /@fontSize@/: default monospace font size to be set in pixels -} + -> m () +settingsSetDefaultMonospaceFontSize settings fontSize = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + webkit_settings_set_default_monospace_font_size settings' fontSize + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetDefaultMonospaceFontSizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetDefaultMonospaceFontSizeMethodInfo a signature where + overloadedMethod _ = settingsSetDefaultMonospaceFontSize + +#endif + +-- method Settings::set_draw_compositing_indicators +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_draw_compositing_indicators" webkit_settings_set_draw_compositing_indicators :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/draw-compositing-indicators/@ property. +-} +settingsSetDrawCompositingIndicators :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetDrawCompositingIndicators settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_draw_compositing_indicators settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetDrawCompositingIndicatorsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetDrawCompositingIndicatorsMethodInfo a signature where + overloadedMethod _ = settingsSetDrawCompositingIndicators + +#endif + +-- method Settings::set_enable_accelerated_2d_canvas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_accelerated_2d_canvas" webkit_settings_set_enable_accelerated_2d_canvas :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-accelerated-2d-canvas/@ property. + +/Since: 2.2/ +-} +settingsSetEnableAccelerated2dCanvas :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableAccelerated2dCanvas settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_accelerated_2d_canvas settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableAccelerated2dCanvasMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableAccelerated2dCanvasMethodInfo a signature where + overloadedMethod _ = settingsSetEnableAccelerated2dCanvas + +#endif + +-- method Settings::set_enable_back_forward_navigation_gestures +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_back_forward_navigation_gestures" webkit_settings_set_enable_back_forward_navigation_gestures :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-back-forward-navigation-gestures/@ property. + +/Since: 2.24/ +-} +settingsSetEnableBackForwardNavigationGestures :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: value to be set -} + -> m () +settingsSetEnableBackForwardNavigationGestures settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_back_forward_navigation_gestures settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableBackForwardNavigationGesturesMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableBackForwardNavigationGesturesMethodInfo a signature where + overloadedMethod _ = settingsSetEnableBackForwardNavigationGestures + +#endif + +-- method Settings::set_enable_caret_browsing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_caret_browsing" webkit_settings_set_enable_caret_browsing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-caret-browsing/@ property. +-} +settingsSetEnableCaretBrowsing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableCaretBrowsing settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_caret_browsing settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableCaretBrowsingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableCaretBrowsingMethodInfo a signature where + overloadedMethod _ = settingsSetEnableCaretBrowsing + +#endif + +-- method Settings::set_enable_developer_extras +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_developer_extras" webkit_settings_set_enable_developer_extras :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-developer-extras/@ property. +-} +settingsSetEnableDeveloperExtras :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableDeveloperExtras settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_developer_extras settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableDeveloperExtrasMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableDeveloperExtrasMethodInfo a signature where + overloadedMethod _ = settingsSetEnableDeveloperExtras + +#endif + +-- method Settings::set_enable_dns_prefetching +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_dns_prefetching" webkit_settings_set_enable_dns_prefetching :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-dns-prefetching/@ property. +-} +settingsSetEnableDnsPrefetching :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableDnsPrefetching settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_dns_prefetching settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableDnsPrefetchingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableDnsPrefetchingMethodInfo a signature where + overloadedMethod _ = settingsSetEnableDnsPrefetching + +#endif + +-- method Settings::set_enable_encrypted_media +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_encrypted_media" webkit_settings_set_enable_encrypted_media :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-encrypted-media/@ property. + +/Since: 2.20/ +-} +settingsSetEnableEncryptedMedia :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableEncryptedMedia settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_encrypted_media settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableEncryptedMediaMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableEncryptedMediaMethodInfo a signature where + overloadedMethod _ = settingsSetEnableEncryptedMedia + +#endif + +-- method Settings::set_enable_frame_flattening +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_frame_flattening" webkit_settings_set_enable_frame_flattening :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-frame-flattening/@ property. +-} +settingsSetEnableFrameFlattening :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableFrameFlattening settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_frame_flattening settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableFrameFlatteningMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableFrameFlatteningMethodInfo a signature where + overloadedMethod _ = settingsSetEnableFrameFlattening + +#endif + +-- method Settings::set_enable_fullscreen +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_fullscreen" webkit_settings_set_enable_fullscreen :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-fullscreen/@ property. +-} +settingsSetEnableFullscreen :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableFullscreen settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_fullscreen settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableFullscreenMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableFullscreenMethodInfo a signature where + overloadedMethod _ = settingsSetEnableFullscreen + +#endif + +-- method Settings::set_enable_html5_database +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_html5_database" webkit_settings_set_enable_html5_database :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-html5-database/@ property. +-} +settingsSetEnableHtml5Database :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableHtml5Database settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_html5_database settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableHtml5DatabaseMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableHtml5DatabaseMethodInfo a signature where + overloadedMethod _ = settingsSetEnableHtml5Database + +#endif + +-- method Settings::set_enable_html5_local_storage +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_html5_local_storage" webkit_settings_set_enable_html5_local_storage :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-html5-local-storage/@ property. +-} +settingsSetEnableHtml5LocalStorage :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableHtml5LocalStorage settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_html5_local_storage settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableHtml5LocalStorageMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableHtml5LocalStorageMethodInfo a signature where + overloadedMethod _ = settingsSetEnableHtml5LocalStorage + +#endif + +-- method Settings::set_enable_hyperlink_auditing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_hyperlink_auditing" webkit_settings_set_enable_hyperlink_auditing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-hyperlink-auditing/@ property. +-} +settingsSetEnableHyperlinkAuditing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableHyperlinkAuditing settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_hyperlink_auditing settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableHyperlinkAuditingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableHyperlinkAuditingMethodInfo a signature where + overloadedMethod _ = settingsSetEnableHyperlinkAuditing + +#endif + +-- method Settings::set_enable_java +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_java" webkit_settings_set_enable_java :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-java/@ property. +-} +settingsSetEnableJava :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableJava settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_java settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableJavaMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableJavaMethodInfo a signature where + overloadedMethod _ = settingsSetEnableJava + +#endif + +-- method Settings::set_enable_javascript +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_javascript" webkit_settings_set_enable_javascript :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-javascript/@ property. +-} +settingsSetEnableJavascript :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableJavascript settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_javascript settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableJavascriptMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableJavascriptMethodInfo a signature where + overloadedMethod _ = settingsSetEnableJavascript + +#endif + +-- method Settings::set_enable_javascript_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_javascript_markup" webkit_settings_set_enable_javascript_markup :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-javascript-markup/@ property. + +/Since: 2.24/ +-} +settingsSetEnableJavascriptMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableJavascriptMarkup settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_javascript_markup settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableJavascriptMarkupMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableJavascriptMarkupMethodInfo a signature where + overloadedMethod _ = settingsSetEnableJavascriptMarkup + +#endif + +-- method Settings::set_enable_media_capabilities +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_media_capabilities" webkit_settings_set_enable_media_capabilities :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-media-capabilities/@ property. + +/Since: 2.22/ +-} +settingsSetEnableMediaCapabilities :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableMediaCapabilities settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_media_capabilities settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableMediaCapabilitiesMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableMediaCapabilitiesMethodInfo a signature where + overloadedMethod _ = settingsSetEnableMediaCapabilities + +#endif + +-- method Settings::set_enable_media_stream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_media_stream" webkit_settings_set_enable_media_stream :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-media-stream/@ property. + +/Since: 2.4/ +-} +settingsSetEnableMediaStream :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableMediaStream settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_media_stream settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableMediaStreamMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableMediaStreamMethodInfo a signature where + overloadedMethod _ = settingsSetEnableMediaStream + +#endif + +-- method Settings::set_enable_mediasource +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_mediasource" webkit_settings_set_enable_mediasource :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-mediasource/@ property. + +/Since: 2.4/ +-} +settingsSetEnableMediasource :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableMediasource settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_mediasource settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableMediasourceMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableMediasourceMethodInfo a signature where + overloadedMethod _ = settingsSetEnableMediasource + +#endif + +-- method Settings::set_enable_mock_capture_devices +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_mock_capture_devices" webkit_settings_set_enable_mock_capture_devices :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-mock-capture-devices/@ property. + +/Since: 2.4/ +-} +settingsSetEnableMockCaptureDevices :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableMockCaptureDevices settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_mock_capture_devices settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableMockCaptureDevicesMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableMockCaptureDevicesMethodInfo a signature where + overloadedMethod _ = settingsSetEnableMockCaptureDevices + +#endif + +-- method Settings::set_enable_offline_web_application_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_offline_web_application_cache" webkit_settings_set_enable_offline_web_application_cache :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-offline-web-application-cache/@ property. +-} +settingsSetEnableOfflineWebApplicationCache :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableOfflineWebApplicationCache settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_offline_web_application_cache settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableOfflineWebApplicationCacheMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableOfflineWebApplicationCacheMethodInfo a signature where + overloadedMethod _ = settingsSetEnableOfflineWebApplicationCache + +#endif + +-- method Settings::set_enable_page_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_page_cache" webkit_settings_set_enable_page_cache :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-page-cache/@ property. +-} +settingsSetEnablePageCache :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnablePageCache settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_page_cache settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnablePageCacheMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnablePageCacheMethodInfo a signature where + overloadedMethod _ = settingsSetEnablePageCache + +#endif + +-- method Settings::set_enable_plugins +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_plugins" webkit_settings_set_enable_plugins :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-plugins/@ property. +-} +settingsSetEnablePlugins :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnablePlugins settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_plugins settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnablePluginsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnablePluginsMethodInfo a signature where + overloadedMethod _ = settingsSetEnablePlugins + +#endif + +-- method Settings::set_enable_private_browsing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_private_browsing" webkit_settings_set_enable_private_browsing :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{-# DEPRECATED settingsSetEnablePrivateBrowsing ["(Since version 2.16.)","Use 'GI.WebKit2.Objects.WebView.WebView':@/is-ephemeral/@ or 'GI.WebKit2.Objects.WebContext.WebContext':@/is-ephemeral/@ instead."] #-} +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-private-browsing/@ property. +-} +settingsSetEnablePrivateBrowsing :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnablePrivateBrowsing settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_private_browsing settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnablePrivateBrowsingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnablePrivateBrowsingMethodInfo a signature where + overloadedMethod _ = settingsSetEnablePrivateBrowsing + +#endif + +-- method Settings::set_enable_resizable_text_areas +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_resizable_text_areas" webkit_settings_set_enable_resizable_text_areas :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-resizable-text-areas/@ property. +-} +settingsSetEnableResizableTextAreas :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableResizableTextAreas settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_resizable_text_areas settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableResizableTextAreasMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableResizableTextAreasMethodInfo a signature where + overloadedMethod _ = settingsSetEnableResizableTextAreas + +#endif + +-- method Settings::set_enable_site_specific_quirks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_site_specific_quirks" webkit_settings_set_enable_site_specific_quirks :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-site-specific-quirks/@ property. +-} +settingsSetEnableSiteSpecificQuirks :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableSiteSpecificQuirks settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_site_specific_quirks settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableSiteSpecificQuirksMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableSiteSpecificQuirksMethodInfo a signature where + overloadedMethod _ = settingsSetEnableSiteSpecificQuirks + +#endif + +-- method Settings::set_enable_smooth_scrolling +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_smooth_scrolling" webkit_settings_set_enable_smooth_scrolling :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-smooth-scrolling/@ property. +-} +settingsSetEnableSmoothScrolling :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableSmoothScrolling settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_smooth_scrolling settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableSmoothScrollingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableSmoothScrollingMethodInfo a signature where + overloadedMethod _ = settingsSetEnableSmoothScrolling + +#endif + +-- method Settings::set_enable_spatial_navigation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_spatial_navigation" webkit_settings_set_enable_spatial_navigation :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-spatial-navigation/@ property. + +/Since: 2.2/ +-} +settingsSetEnableSpatialNavigation :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableSpatialNavigation settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_spatial_navigation settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableSpatialNavigationMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableSpatialNavigationMethodInfo a signature where + overloadedMethod _ = settingsSetEnableSpatialNavigation + +#endif + +-- method Settings::set_enable_tabs_to_links +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_tabs_to_links" webkit_settings_set_enable_tabs_to_links :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-tabs-to-links/@ property. +-} +settingsSetEnableTabsToLinks :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableTabsToLinks settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_tabs_to_links settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableTabsToLinksMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableTabsToLinksMethodInfo a signature where + overloadedMethod _ = settingsSetEnableTabsToLinks + +#endif + +-- method Settings::set_enable_webaudio +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_webaudio" webkit_settings_set_enable_webaudio :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-webaudio/@ property. +-} +settingsSetEnableWebaudio :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableWebaudio settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_webaudio settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableWebaudioMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableWebaudioMethodInfo a signature where + overloadedMethod _ = settingsSetEnableWebaudio + +#endif + +-- method Settings::set_enable_webgl +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_webgl" webkit_settings_set_enable_webgl :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-webgl/@ property. +-} +settingsSetEnableWebgl :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableWebgl settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_webgl settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableWebglMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableWebglMethodInfo a signature where + overloadedMethod _ = settingsSetEnableWebgl + +#endif + +-- method Settings::set_enable_write_console_messages_to_stdout +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_write_console_messages_to_stdout" webkit_settings_set_enable_write_console_messages_to_stdout :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-write-console-messages-to-stdout/@ property. + +/Since: 2.2/ +-} +settingsSetEnableWriteConsoleMessagesToStdout :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableWriteConsoleMessagesToStdout settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_write_console_messages_to_stdout settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableWriteConsoleMessagesToStdoutMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableWriteConsoleMessagesToStdoutMethodInfo a signature where + overloadedMethod _ = settingsSetEnableWriteConsoleMessagesToStdout + +#endif + +-- method Settings::set_enable_xss_auditor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_enable_xss_auditor" webkit_settings_set_enable_xss_auditor :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/enable-xss-auditor/@ property. +-} +settingsSetEnableXssAuditor :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetEnableXssAuditor settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_enable_xss_auditor settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetEnableXssAuditorMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetEnableXssAuditorMethodInfo a signature where + overloadedMethod _ = settingsSetEnableXssAuditor + +#endif + +-- method Settings::set_fantasy_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fantasy_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default fantasy font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_fantasy_font_family" webkit_settings_set_fantasy_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- fantasy_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/fantasy-font-family/@ property. +-} +settingsSetFantasyFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@fantasyFontFamily@/: the new default fantasy font family -} + -> m () +settingsSetFantasyFontFamily settings fantasyFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + fantasyFontFamily' <- textToCString fantasyFontFamily + webkit_settings_set_fantasy_font_family settings' fantasyFontFamily' + touchManagedPtr settings + freeMem fantasyFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetFantasyFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetFantasyFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetFantasyFontFamily + +#endif + +-- method Settings::set_hardware_acceleration_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "policy", argType = TInterface (Name {namespace = "WebKit2", name = "HardwareAccelerationPolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitHardwareAccelerationPolicy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_hardware_acceleration_policy" webkit_settings_set_hardware_acceleration_policy :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CUInt -> -- policy : TInterface (Name {namespace = "WebKit2", name = "HardwareAccelerationPolicy"}) + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/hardware-acceleration-policy/@ property. + +/Since: 2.16/ +-} +settingsSetHardwareAccelerationPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> WebKit2.Enums.HardwareAccelerationPolicy + {- ^ /@policy@/: a 'GI.WebKit2.Enums.HardwareAccelerationPolicy' -} + -> m () +settingsSetHardwareAccelerationPolicy settings policy = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let policy' = (fromIntegral . fromEnum) policy + webkit_settings_set_hardware_acceleration_policy settings' policy' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetHardwareAccelerationPolicyMethodInfo +instance (signature ~ (WebKit2.Enums.HardwareAccelerationPolicy -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetHardwareAccelerationPolicyMethodInfo a signature where + overloadedMethod _ = settingsSetHardwareAccelerationPolicy + +#endif + +-- method Settings::set_javascript_can_access_clipboard +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_javascript_can_access_clipboard" webkit_settings_set_javascript_can_access_clipboard :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/javascript-can-access-clipboard/@ property. +-} +settingsSetJavascriptCanAccessClipboard :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetJavascriptCanAccessClipboard settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_javascript_can_access_clipboard settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetJavascriptCanAccessClipboardMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetJavascriptCanAccessClipboardMethodInfo a signature where + overloadedMethod _ = settingsSetJavascriptCanAccessClipboard + +#endif + +-- method Settings::set_javascript_can_open_windows_automatically +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_javascript_can_open_windows_automatically" webkit_settings_set_javascript_can_open_windows_automatically :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/javascript-can-open-windows-automatically/@ property. +-} +settingsSetJavascriptCanOpenWindowsAutomatically :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetJavascriptCanOpenWindowsAutomatically settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_javascript_can_open_windows_automatically settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetJavascriptCanOpenWindowsAutomaticallyMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetJavascriptCanOpenWindowsAutomaticallyMethodInfo a signature where + overloadedMethod _ = settingsSetJavascriptCanOpenWindowsAutomatically + +#endif + +-- method Settings::set_load_icons_ignoring_image_load_setting +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_load_icons_ignoring_image_load_setting" webkit_settings_set_load_icons_ignoring_image_load_setting :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/load-icons-ignoring-image-load-setting/@ property. +-} +settingsSetLoadIconsIgnoringImageLoadSetting :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetLoadIconsIgnoringImageLoadSetting settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_load_icons_ignoring_image_load_setting settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetLoadIconsIgnoringImageLoadSettingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetLoadIconsIgnoringImageLoadSettingMethodInfo a signature where + overloadedMethod _ = settingsSetLoadIconsIgnoringImageLoadSetting + +#endif + +-- method Settings::set_media_playback_allows_inline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_media_playback_allows_inline" webkit_settings_set_media_playback_allows_inline :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/media-playback-allows-inline/@ property. +-} +settingsSetMediaPlaybackAllowsInline :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetMediaPlaybackAllowsInline settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_media_playback_allows_inline settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetMediaPlaybackAllowsInlineMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetMediaPlaybackAllowsInlineMethodInfo a signature where + overloadedMethod _ = settingsSetMediaPlaybackAllowsInline + +#endif + +-- method Settings::set_media_playback_requires_user_gesture +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_media_playback_requires_user_gesture" webkit_settings_set_media_playback_requires_user_gesture :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/media-playback-requires-user-gesture/@ property. +-} +settingsSetMediaPlaybackRequiresUserGesture :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +settingsSetMediaPlaybackRequiresUserGesture settings enabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let enabled' = (fromIntegral . fromEnum) enabled + webkit_settings_set_media_playback_requires_user_gesture settings' enabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetMediaPlaybackRequiresUserGestureMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetMediaPlaybackRequiresUserGestureMethodInfo a signature where + overloadedMethod _ = settingsSetMediaPlaybackRequiresUserGesture + +#endif + +-- method Settings::set_minimum_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minimum font size to be set in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_minimum_font_size" webkit_settings_set_minimum_font_size :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + Word32 -> -- font_size : TBasicType TUInt32 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/minimum-font-size/@ property. +-} +settingsSetMinimumFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Word32 + {- ^ /@fontSize@/: minimum font size to be set in pixels -} + -> m () +settingsSetMinimumFontSize settings fontSize = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + webkit_settings_set_minimum_font_size settings' fontSize + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetMinimumFontSizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetMinimumFontSizeMethodInfo a signature where + overloadedMethod _ = settingsSetMinimumFontSize + +#endif + +-- method Settings::set_monospace_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "monospace_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default monospace font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_monospace_font_family" webkit_settings_set_monospace_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- monospace_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/monospace-font-family/@ property. +-} +settingsSetMonospaceFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@monospaceFontFamily@/: the new default monospace font family -} + -> m () +settingsSetMonospaceFontFamily settings monospaceFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + monospaceFontFamily' <- textToCString monospaceFontFamily + webkit_settings_set_monospace_font_family settings' monospaceFontFamily' + touchManagedPtr settings + freeMem monospaceFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetMonospaceFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetMonospaceFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetMonospaceFontFamily + +#endif + +-- method Settings::set_pictograph_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pictograph_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default pictograph font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_pictograph_font_family" webkit_settings_set_pictograph_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- pictograph_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/pictograph-font-family/@ property. +-} +settingsSetPictographFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@pictographFontFamily@/: the new default pictograph font family -} + -> m () +settingsSetPictographFontFamily settings pictographFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + pictographFontFamily' <- textToCString pictographFontFamily + webkit_settings_set_pictograph_font_family settings' pictographFontFamily' + touchManagedPtr settings + freeMem pictographFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetPictographFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetPictographFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetPictographFontFamily + +#endif + +-- method Settings::set_print_backgrounds +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "print_backgrounds", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_print_backgrounds" webkit_settings_set_print_backgrounds :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- print_backgrounds : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/print-backgrounds/@ property. +-} +settingsSetPrintBackgrounds :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@printBackgrounds@/: Value to be set -} + -> m () +settingsSetPrintBackgrounds settings printBackgrounds = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let printBackgrounds' = (fromIntegral . fromEnum) printBackgrounds + webkit_settings_set_print_backgrounds settings' printBackgrounds' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetPrintBackgroundsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetPrintBackgroundsMethodInfo a signature where + overloadedMethod _ = settingsSetPrintBackgrounds + +#endif + +-- method Settings::set_sans_serif_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sans_serif_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default sans-serif font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_sans_serif_font_family" webkit_settings_set_sans_serif_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- sans_serif_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/sans-serif-font-family/@ property. +-} +settingsSetSansSerifFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@sansSerifFontFamily@/: the new default sans-serif font family -} + -> m () +settingsSetSansSerifFontFamily settings sansSerifFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + sansSerifFontFamily' <- textToCString sansSerifFontFamily + webkit_settings_set_sans_serif_font_family settings' sansSerifFontFamily' + touchManagedPtr settings + freeMem sansSerifFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetSansSerifFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetSansSerifFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetSansSerifFontFamily + +#endif + +-- method Settings::set_serif_font_family +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "serif_font_family", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default serif font family", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_serif_font_family" webkit_settings_set_serif_font_family :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- serif_font_family : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/serif-font-family/@ property. +-} +settingsSetSerifFontFamily :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> T.Text + {- ^ /@serifFontFamily@/: the new default serif font family -} + -> m () +settingsSetSerifFontFamily settings serifFontFamily = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + serifFontFamily' <- textToCString serifFontFamily + webkit_settings_set_serif_font_family settings' serifFontFamily' + touchManagedPtr settings + freeMem serifFontFamily' + return () + +#if ENABLE_OVERLOADING +data SettingsSetSerifFontFamilyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetSerifFontFamilyMethodInfo a signature where + overloadedMethod _ = settingsSetSerifFontFamily + +#endif + +-- method Settings::set_user_agent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_agent", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The new custom user agent string or %NULL to use the default user agent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_user_agent" webkit_settings_set_user_agent :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- user_agent : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/user-agent/@ property. +-} +settingsSetUserAgent :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Maybe (T.Text) + {- ^ /@userAgent@/: The new custom user agent string or 'Nothing' to use the default user agent -} + -> m () +settingsSetUserAgent settings userAgent = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + maybeUserAgent <- case userAgent of + Nothing -> return nullPtr + Just jUserAgent -> do + jUserAgent' <- textToCString jUserAgent + return jUserAgent' + webkit_settings_set_user_agent settings' maybeUserAgent + touchManagedPtr settings + freeMem maybeUserAgent + return () + +#if ENABLE_OVERLOADING +data SettingsSetUserAgentMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetUserAgentMethodInfo a signature where + overloadedMethod _ = settingsSetUserAgent + +#endif + +-- method Settings::set_user_agent_with_application_details +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "application_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The application name used for the user agent or %NULL to use the default user agent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "application_version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The application version for the user agent or %NULL to user the default version.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_user_agent_with_application_details" webkit_settings_set_user_agent_with_application_details :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CString -> -- application_name : TBasicType TUTF8 + CString -> -- application_version : TBasicType TUTF8 + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/user-agent/@ property by appending the application details to the default user +agent. If no application name or version is given, the default user agent used will be used. If only +the version is given, the default engine version is used with the given application name. +-} +settingsSetUserAgentWithApplicationDetails :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Maybe (T.Text) + {- ^ /@applicationName@/: The application name used for the user agent or 'Nothing' to use the default user agent. -} + -> Maybe (T.Text) + {- ^ /@applicationVersion@/: The application version for the user agent or 'Nothing' to user the default version. -} + -> m () +settingsSetUserAgentWithApplicationDetails settings applicationName applicationVersion = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + maybeApplicationName <- case applicationName of + Nothing -> return nullPtr + Just jApplicationName -> do + jApplicationName' <- textToCString jApplicationName + return jApplicationName' + maybeApplicationVersion <- case applicationVersion of + Nothing -> return nullPtr + Just jApplicationVersion -> do + jApplicationVersion' <- textToCString jApplicationVersion + return jApplicationVersion' + webkit_settings_set_user_agent_with_application_details settings' maybeApplicationName maybeApplicationVersion + touchManagedPtr settings + freeMem maybeApplicationName + freeMem maybeApplicationVersion + return () + +#if ENABLE_OVERLOADING +data SettingsSetUserAgentWithApplicationDetailsMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetUserAgentWithApplicationDetailsMethodInfo a signature where + overloadedMethod _ = settingsSetUserAgentWithApplicationDetails + +#endif + +-- method Settings::set_zoom_text_only +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "zoom_text_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_set_zoom_text_only" webkit_settings_set_zoom_text_only :: + Ptr Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + CInt -> -- zoom_text_only : TBasicType TBoolean + IO () + +{- | +Set the 'GI.WebKit2.Objects.Settings.Settings':@/zoom-text-only/@ property. +-} +settingsSetZoomTextOnly :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> Bool + {- ^ /@zoomTextOnly@/: Value to be set -} + -> m () +settingsSetZoomTextOnly settings zoomTextOnly = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let zoomTextOnly' = (fromIntegral . fromEnum) zoomTextOnly + webkit_settings_set_zoom_text_only settings' zoomTextOnly' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SettingsSetZoomTextOnlyMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSettings a) => O.MethodInfo SettingsSetZoomTextOnlyMethodInfo a signature where + overloadedMethod _ = settingsSetZoomTextOnly + +#endif + +-- method Settings::font_size_to_pixels +-- method type : MemberFunction +-- Args : [Arg {argCName = "points", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the font size in points to convert to pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_font_size_to_pixels" webkit_settings_font_size_to_pixels :: + Word32 -> -- points : TBasicType TUInt32 + IO Word32 + +{- | +Convert /@points@/ to the equivalent value in pixels, based on the current +screen DPI. Applications can use this function to convert font size values +in points to font size values in pixels when setting the font size properties +of 'GI.WebKit2.Objects.Settings.Settings'. + +/Since: 2.20/ +-} +settingsFontSizeToPixels :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@points@/: the font size in points to convert to pixels -} + -> m Word32 + {- ^ __Returns:__ the equivalent font size in pixels. -} +settingsFontSizeToPixels points = liftIO $ do + result <- webkit_settings_font_size_to_pixels points + return result + +#if ENABLE_OVERLOADING +#endif + +-- method Settings::font_size_to_points +-- method type : MemberFunction +-- Args : [Arg {argCName = "pixels", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the font size in pixels to convert to points", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_settings_font_size_to_points" webkit_settings_font_size_to_points :: + Word32 -> -- pixels : TBasicType TUInt32 + IO Word32 + +{- | +Convert /@pixels@/ to the equivalent value in points, based on the current +screen DPI. Applications can use this function to convert font size values +in pixels to font size values in points when getting the font size properties +of 'GI.WebKit2.Objects.Settings.Settings'. + +/Since: 2.20/ +-} +settingsFontSizeToPoints :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@pixels@/: the font size in pixels to convert to points -} + -> m Word32 + {- ^ __Returns:__ the equivalent font size in points. -} +settingsFontSizeToPoints pixels = liftIO $ do + result <- webkit_settings_font_size_to_points pixels + return result + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/WebKit2/Objects/Settings.hs-boot b/GI/WebKit2/Objects/Settings.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/Settings.hs-boot @@ -0,0 +1,536 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.Settings 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 + +newtype Settings = Settings (ManagedPtr Settings) +instance GObject Settings where +class (GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance (GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance O.HasParentTypes Settings +#if ENABLE_OVERLOADING +data SettingsAllowFileAccessFromFileUrlsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsAllowModalDialogsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsAllowUniversalAccessFromFileUrlsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsAutoLoadImagesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsCursiveFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsDefaultCharsetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsDefaultFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsDefaultFontSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsDefaultMonospaceFontSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsDrawCompositingIndicatorsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableAccelerated2dCanvasPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableBackForwardNavigationGesturesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableCaretBrowsingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableDeveloperExtrasPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableDnsPrefetchingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableEncryptedMediaPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableFrameFlatteningPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableFullscreenPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableHtml5DatabasePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableHtml5LocalStoragePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableHyperlinkAuditingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableJavaPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableJavascriptPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableJavascriptMarkupPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableMediaCapabilitiesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableMediaStreamPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableMediasourcePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableMockCaptureDevicesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableOfflineWebApplicationCachePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnablePageCachePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnablePluginsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnablePrivateBrowsingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableResizableTextAreasPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableSiteSpecificQuirksPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableSmoothScrollingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableSpatialNavigationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableTabsToLinksPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableWebaudioPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableWebglPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableWriteConsoleMessagesToStdoutPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsEnableXssAuditorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsFantasyFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsHardwareAccelerationPolicyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsJavascriptCanAccessClipboardPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsJavascriptCanOpenWindowsAutomaticallyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsLoadIconsIgnoringImageLoadSettingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsMediaPlaybackAllowsInlinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsMediaPlaybackRequiresUserGesturePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsMinimumFontSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsMonospaceFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsPictographFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsPrintBackgroundsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSansSerifFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSerifFontFamilyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsUserAgentPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsZoomTextOnlyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetAllowFileAccessFromFileUrlsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetAllowModalDialogsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetAllowUniversalAccessFromFileUrlsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetAutoLoadImagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetCursiveFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetDefaultCharsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetDefaultFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetDefaultFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetDefaultMonospaceFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetDrawCompositingIndicatorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableAccelerated2dCanvasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableBackForwardNavigationGesturesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableCaretBrowsingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableDeveloperExtrasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableDnsPrefetchingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableEncryptedMediaMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableFrameFlatteningMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableFullscreenMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableHtml5DatabaseMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableHtml5LocalStorageMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableHyperlinkAuditingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableJavaMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableJavascriptMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableJavascriptMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableMediaCapabilitiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableMediaStreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableMediasourceMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableMockCaptureDevicesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableOfflineWebApplicationCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnablePageCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnablePluginsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnablePrivateBrowsingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableResizableTextAreasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableSiteSpecificQuirksMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableSmoothScrollingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableSpatialNavigationMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableTabsToLinksMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableWebaudioMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableWebglMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableWriteConsoleMessagesToStdoutMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetEnableXssAuditorMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetFantasyFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetHardwareAccelerationPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetJavascriptCanAccessClipboardMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetJavascriptCanOpenWindowsAutomaticallyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetLoadIconsIgnoringImageLoadSettingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetMediaPlaybackAllowsInlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetMediaPlaybackRequiresUserGestureMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetMinimumFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetMonospaceFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetPictographFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetPrintBackgroundsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetSansSerifFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetSerifFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetUserAgentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsGetZoomTextOnlyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetAllowFileAccessFromFileUrlsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetAllowModalDialogsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetAllowUniversalAccessFromFileUrlsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetAutoLoadImagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetCursiveFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetDefaultCharsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetDefaultFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetDefaultFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetDefaultMonospaceFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetDrawCompositingIndicatorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableAccelerated2dCanvasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableBackForwardNavigationGesturesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableCaretBrowsingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableDeveloperExtrasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableDnsPrefetchingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableEncryptedMediaMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableFrameFlatteningMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableFullscreenMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableHtml5DatabaseMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableHtml5LocalStorageMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableHyperlinkAuditingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableJavaMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableJavascriptMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableJavascriptMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableMediaCapabilitiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableMediaStreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableMediasourceMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableMockCaptureDevicesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableOfflineWebApplicationCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnablePageCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnablePluginsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnablePrivateBrowsingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableResizableTextAreasMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableSiteSpecificQuirksMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableSmoothScrollingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableSpatialNavigationMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableTabsToLinksMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableWebaudioMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableWebglMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableWriteConsoleMessagesToStdoutMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetEnableXssAuditorMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetFantasyFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetHardwareAccelerationPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetJavascriptCanAccessClipboardMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetJavascriptCanOpenWindowsAutomaticallyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetLoadIconsIgnoringImageLoadSettingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetMediaPlaybackAllowsInlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetMediaPlaybackRequiresUserGestureMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetMinimumFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetMonospaceFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetPictographFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetPrintBackgroundsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetSansSerifFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetSerifFontFamilyMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetUserAgentMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetUserAgentWithApplicationDetailsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SettingsSetZoomTextOnlyMethodInfo +#endif diff --git a/GI/WebKit2/Objects/URIRequest.hs b/GI/WebKit2/Objects/URIRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URIRequest.hs @@ -0,0 +1,417 @@ + + +{- | +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.URIRequest + ( + +-- * Exported types + URIRequest(..) , + IsURIRequest , + toURIRequest , + noURIRequest , + + + -- * Methods +-- ** getHttpHeaders #method:getHttpHeaders# + +#if ENABLE_OVERLOADING + URIRequestGetHttpHeadersMethodInfo , +#endif + uRIRequestGetHttpHeaders , + + +-- ** getHttpMethod #method:getHttpMethod# + +#if ENABLE_OVERLOADING + URIRequestGetHttpMethodMethodInfo , +#endif + uRIRequestGetHttpMethod , + + +-- ** getUri #method:getUri# + +#if ENABLE_OVERLOADING + URIRequestGetUriMethodInfo , +#endif + uRIRequestGetUri , + + +-- ** new #method:new# + + uRIRequestNew , + + +-- ** setUri #method:setUri# + +#if ENABLE_OVERLOADING + URIRequestSetUriMethodInfo , +#endif + uRIRequestSetUri , + + + + + -- * Properties +-- ** uri #attr:uri# +{- | The URI to which the request will be made. +-} +#if ENABLE_OVERLOADING + URIRequestUriPropertyInfo , +#endif + constructURIRequestUri , + getURIRequestUri , + setURIRequestUri , +#if ENABLE_OVERLOADING + uRIRequestUri , +#endif + + + + + ) 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.Soup.Structs.MessageHeaders as Soup.MessageHeaders + +-- | Memory-managed wrapper type. +newtype URIRequest = URIRequest (ManagedPtr URIRequest) +foreign import ccall "webkit_uri_request_get_type" + c_webkit_uri_request_get_type :: IO GType + +instance GObject URIRequest where + gobjectType = c_webkit_uri_request_get_type + + +-- | Type class for types which can be safely cast to `URIRequest`, for instance with `toURIRequest`. +class (GObject o, O.IsDescendantOf URIRequest o) => IsURIRequest o +instance (GObject o, O.IsDescendantOf URIRequest o) => IsURIRequest o + +instance O.HasParentTypes URIRequest +type instance O.ParentTypes URIRequest = '[GObject.Object.Object] + +-- | Cast to `URIRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toURIRequest :: (MonadIO m, IsURIRequest o) => o -> m URIRequest +toURIRequest = liftIO . unsafeCastTo URIRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `URIRequest`. +noURIRequest :: Maybe URIRequest +noURIRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveURIRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveURIRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveURIRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveURIRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveURIRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveURIRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveURIRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveURIRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveURIRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveURIRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveURIRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveURIRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveURIRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveURIRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveURIRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveURIRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveURIRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveURIRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveURIRequestMethod "getHttpHeaders" o = URIRequestGetHttpHeadersMethodInfo + ResolveURIRequestMethod "getHttpMethod" o = URIRequestGetHttpMethodMethodInfo + ResolveURIRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveURIRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveURIRequestMethod "getUri" o = URIRequestGetUriMethodInfo + ResolveURIRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveURIRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveURIRequestMethod "setUri" o = URIRequestSetUriMethodInfo + ResolveURIRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveURIRequestMethod t URIRequest, O.MethodInfo info URIRequest p) => OL.IsLabel t (URIRequest -> 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 + +-- VVV Prop "uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIRequest #uri +@ +-} +getURIRequestUri :: (MonadIO m, IsURIRequest o) => o -> m T.Text +getURIRequestUri obj = liftIO $ checkUnexpectedNothing "getURIRequestUri" $ B.Properties.getObjectPropertyString obj "uri" + +{- | +Set the value of the “@uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' uRIRequest [ #uri 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setURIRequestUri :: (MonadIO m, IsURIRequest o) => o -> T.Text -> m () +setURIRequestUri obj val = liftIO $ B.Properties.setObjectPropertyString obj "uri" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructURIRequestUri :: (IsURIRequest o) => T.Text -> IO (GValueConstruct o) +constructURIRequestUri val = B.Properties.constructObjectPropertyString "uri" (Just val) + +#if ENABLE_OVERLOADING +data URIRequestUriPropertyInfo +instance AttrInfo URIRequestUriPropertyInfo where + type AttrAllowedOps URIRequestUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint URIRequestUriPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint URIRequestUriPropertyInfo = IsURIRequest + type AttrGetType URIRequestUriPropertyInfo = T.Text + type AttrLabel URIRequestUriPropertyInfo = "uri" + type AttrOrigin URIRequestUriPropertyInfo = URIRequest + attrGet _ = getURIRequestUri + attrSet _ = setURIRequestUri + attrConstruct _ = constructURIRequestUri + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList URIRequest +type instance O.AttributeList URIRequest = URIRequestAttributeList +type URIRequestAttributeList = ('[ '("uri", URIRequestUriPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +uRIRequestUri :: AttrLabelProxy "uri" +uRIRequestUri = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList URIRequest = URIRequestSignalList +type URIRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method URIRequest::new +-- method type : Constructor +-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIRequest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_request_new" webkit_uri_request_new :: + CString -> -- uri : TBasicType TUTF8 + IO (Ptr URIRequest) + +{- | +Creates a new 'GI.WebKit2.Objects.URIRequest.URIRequest' for the given URI. +-} +uRIRequestNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@uri@/: an URI -} + -> m URIRequest + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.URIRequest.URIRequest' -} +uRIRequestNew uri = liftIO $ do + uri' <- textToCString uri + result <- webkit_uri_request_new uri' + checkUnexpectedReturnNULL "uRIRequestNew" result + result' <- (wrapObject URIRequest) result + freeMem uri' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method URIRequest::get_http_headers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Soup", name = "MessageHeaders"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_request_get_http_headers" webkit_uri_request_get_http_headers :: + Ptr URIRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + IO (Ptr Soup.MessageHeaders.MessageHeaders) + +{- | +Get the HTTP headers of a 'GI.WebKit2.Objects.URIRequest.URIRequest' as a 'GI.Soup.Structs.MessageHeaders.MessageHeaders'. +-} +uRIRequestGetHttpHeaders :: + (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} + -> m (Maybe Soup.MessageHeaders.MessageHeaders) + {- ^ __Returns:__ a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' with the HTTP headers of /@request@/ + or 'Nothing' if /@request@/ is not an HTTP request. -} +uRIRequestGetHttpHeaders request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_request_get_http_headers request' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Soup.MessageHeaders.MessageHeaders) result' + return result'' + touchManagedPtr request + return maybeResult + +#if ENABLE_OVERLOADING +data URIRequestGetHttpHeadersMethodInfo +instance (signature ~ (m (Maybe Soup.MessageHeaders.MessageHeaders)), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetHttpHeadersMethodInfo a signature where + overloadedMethod _ = uRIRequestGetHttpHeaders + +#endif + +-- method URIRequest::get_http_method +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest", 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_uri_request_get_http_method" webkit_uri_request_get_http_method :: + Ptr URIRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + IO CString + +{- | +Get the HTTP method of the 'GI.WebKit2.Objects.URIRequest.URIRequest'. + +/Since: 2.12/ +-} +uRIRequestGetHttpMethod :: + (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} + -> m T.Text + {- ^ __Returns:__ the HTTP method of the 'GI.WebKit2.Objects.URIRequest.URIRequest' or 'Nothing' if /@request@/ is not + an HTTP request. -} +uRIRequestGetHttpMethod request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_request_get_http_method request' + checkUnexpectedReturnNULL "uRIRequestGetHttpMethod" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URIRequestGetHttpMethodMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetHttpMethodMethodInfo a signature where + overloadedMethod _ = uRIRequestGetHttpMethod + +#endif + +-- method URIRequest::get_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest", 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_uri_request_get_uri" webkit_uri_request_get_uri :: + Ptr URIRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +uRIRequestGetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} + -> m T.Text + {- ^ __Returns:__ the uri of the 'GI.WebKit2.Objects.URIRequest.URIRequest' -} +uRIRequestGetUri request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_request_get_uri request' + checkUnexpectedReturnNULL "uRIRequestGetUri" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URIRequestGetUriMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestGetUriMethodInfo a signature where + overloadedMethod _ = uRIRequestGetUri + +#endif + +-- method URIRequest::set_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest", 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 "an URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_request_set_uri" webkit_uri_request_set_uri :: + Ptr URIRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + CString -> -- uri : TBasicType TUTF8 + IO () + +{- | +Set the URI of /@request@/ +-} +uRIRequestSetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsURIRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} + -> T.Text + {- ^ /@uri@/: an URI -} + -> m () +uRIRequestSetUri request uri = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + uri' <- textToCString uri + webkit_uri_request_set_uri request' uri' + touchManagedPtr request + freeMem uri' + return () + +#if ENABLE_OVERLOADING +data URIRequestSetUriMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsURIRequest a) => O.MethodInfo URIRequestSetUriMethodInfo a signature where + overloadedMethod _ = uRIRequestSetUri + +#endif + + diff --git a/GI/WebKit2/Objects/URIRequest.hs-boot b/GI/WebKit2/Objects/URIRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URIRequest.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.URIRequest 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 + +newtype URIRequest = URIRequest (ManagedPtr URIRequest) +instance GObject URIRequest where +class (GObject o, O.IsDescendantOf URIRequest o) => IsURIRequest o +instance (GObject o, O.IsDescendantOf URIRequest o) => IsURIRequest o +instance O.HasParentTypes URIRequest +#if ENABLE_OVERLOADING +data URIRequestUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIRequestGetHttpHeadersMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIRequestGetHttpMethodMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIRequestGetUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIRequestSetUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/URIResponse.hs b/GI/WebKit2/Objects/URIResponse.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URIResponse.hs @@ -0,0 +1,684 @@ + + +{- | +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.URIResponse + ( + +-- * Exported types + URIResponse(..) , + IsURIResponse , + toURIResponse , + noURIResponse , + + + -- * Methods +-- ** getContentLength #method:getContentLength# + +#if ENABLE_OVERLOADING + URIResponseGetContentLengthMethodInfo , +#endif + uRIResponseGetContentLength , + + +-- ** getHttpHeaders #method:getHttpHeaders# + +#if ENABLE_OVERLOADING + URIResponseGetHttpHeadersMethodInfo , +#endif + uRIResponseGetHttpHeaders , + + +-- ** getMimeType #method:getMimeType# + +#if ENABLE_OVERLOADING + URIResponseGetMimeTypeMethodInfo , +#endif + uRIResponseGetMimeType , + + +-- ** getStatusCode #method:getStatusCode# + +#if ENABLE_OVERLOADING + URIResponseGetStatusCodeMethodInfo , +#endif + uRIResponseGetStatusCode , + + +-- ** getSuggestedFilename #method:getSuggestedFilename# + +#if ENABLE_OVERLOADING + URIResponseGetSuggestedFilenameMethodInfo, +#endif + uRIResponseGetSuggestedFilename , + + +-- ** getUri #method:getUri# + +#if ENABLE_OVERLOADING + URIResponseGetUriMethodInfo , +#endif + uRIResponseGetUri , + + + + + -- * Properties +-- ** contentLength #attr:contentLength# +{- | The expected content length of the response. +-} +#if ENABLE_OVERLOADING + URIResponseContentLengthPropertyInfo , +#endif + getURIResponseContentLength , +#if ENABLE_OVERLOADING + uRIResponseContentLength , +#endif + + +-- ** httpHeaders #attr:httpHeaders# +{- | The HTTP headers of the response, or 'Nothing' if the response is not an HTTP response. + +/Since: 2.6/ +-} +#if ENABLE_OVERLOADING + URIResponseHttpHeadersPropertyInfo , +#endif + getURIResponseHttpHeaders , +#if ENABLE_OVERLOADING + uRIResponseHttpHeaders , +#endif + + +-- ** mimeType #attr:mimeType# +{- | The MIME type of the response. +-} +#if ENABLE_OVERLOADING + URIResponseMimeTypePropertyInfo , +#endif + getURIResponseMimeType , +#if ENABLE_OVERLOADING + uRIResponseMimeType , +#endif + + +-- ** statusCode #attr:statusCode# +{- | The status code of the response as returned by the server. +-} +#if ENABLE_OVERLOADING + URIResponseStatusCodePropertyInfo , +#endif + getURIResponseStatusCode , +#if ENABLE_OVERLOADING + uRIResponseStatusCode , +#endif + + +-- ** suggestedFilename #attr:suggestedFilename# +{- | The suggested filename for the URI response. +-} +#if ENABLE_OVERLOADING + URIResponseSuggestedFilenamePropertyInfo, +#endif + getURIResponseSuggestedFilename , +#if ENABLE_OVERLOADING + uRIResponseSuggestedFilename , +#endif + + +-- ** uri #attr:uri# +{- | The URI for which the response was made. +-} +#if ENABLE_OVERLOADING + URIResponseUriPropertyInfo , +#endif + getURIResponseUri , +#if ENABLE_OVERLOADING + uRIResponseUri , +#endif + + + + + ) 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.Soup.Structs.MessageHeaders as Soup.MessageHeaders + +-- | Memory-managed wrapper type. +newtype URIResponse = URIResponse (ManagedPtr URIResponse) +foreign import ccall "webkit_uri_response_get_type" + c_webkit_uri_response_get_type :: IO GType + +instance GObject URIResponse where + gobjectType = c_webkit_uri_response_get_type + + +-- | Type class for types which can be safely cast to `URIResponse`, for instance with `toURIResponse`. +class (GObject o, O.IsDescendantOf URIResponse o) => IsURIResponse o +instance (GObject o, O.IsDescendantOf URIResponse o) => IsURIResponse o + +instance O.HasParentTypes URIResponse +type instance O.ParentTypes URIResponse = '[GObject.Object.Object] + +-- | Cast to `URIResponse`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toURIResponse :: (MonadIO m, IsURIResponse o) => o -> m URIResponse +toURIResponse = liftIO . unsafeCastTo URIResponse + +-- | A convenience alias for `Nothing` :: `Maybe` `URIResponse`. +noURIResponse :: Maybe URIResponse +noURIResponse = Nothing + +#if ENABLE_OVERLOADING +type family ResolveURIResponseMethod (t :: Symbol) (o :: *) :: * where + ResolveURIResponseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveURIResponseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveURIResponseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveURIResponseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveURIResponseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveURIResponseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveURIResponseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveURIResponseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveURIResponseMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveURIResponseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveURIResponseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveURIResponseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveURIResponseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveURIResponseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveURIResponseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveURIResponseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveURIResponseMethod "getContentLength" o = URIResponseGetContentLengthMethodInfo + ResolveURIResponseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveURIResponseMethod "getHttpHeaders" o = URIResponseGetHttpHeadersMethodInfo + ResolveURIResponseMethod "getMimeType" o = URIResponseGetMimeTypeMethodInfo + ResolveURIResponseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveURIResponseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveURIResponseMethod "getStatusCode" o = URIResponseGetStatusCodeMethodInfo + ResolveURIResponseMethod "getSuggestedFilename" o = URIResponseGetSuggestedFilenameMethodInfo + ResolveURIResponseMethod "getUri" o = URIResponseGetUriMethodInfo + ResolveURIResponseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveURIResponseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveURIResponseMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveURIResponseMethod t URIResponse, O.MethodInfo info URIResponse p) => OL.IsLabel t (URIResponse -> 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 + +-- VVV Prop "content-length" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@content-length@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIResponse #contentLength +@ +-} +getURIResponseContentLength :: (MonadIO m, IsURIResponse o) => o -> m Word64 +getURIResponseContentLength obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "content-length" + +#if ENABLE_OVERLOADING +data URIResponseContentLengthPropertyInfo +instance AttrInfo URIResponseContentLengthPropertyInfo where + type AttrAllowedOps URIResponseContentLengthPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint URIResponseContentLengthPropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseContentLengthPropertyInfo = IsURIResponse + type AttrGetType URIResponseContentLengthPropertyInfo = Word64 + type AttrLabel URIResponseContentLengthPropertyInfo = "content-length" + type AttrOrigin URIResponseContentLengthPropertyInfo = URIResponse + attrGet _ = getURIResponseContentLength + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "http-headers" + -- Type: TInterface (Name {namespace = "Soup", name = "MessageHeaders"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@http-headers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIResponse #httpHeaders +@ +-} +getURIResponseHttpHeaders :: (MonadIO m, IsURIResponse o) => o -> m (Maybe Soup.MessageHeaders.MessageHeaders) +getURIResponseHttpHeaders obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "http-headers" Soup.MessageHeaders.MessageHeaders + +#if ENABLE_OVERLOADING +data URIResponseHttpHeadersPropertyInfo +instance AttrInfo URIResponseHttpHeadersPropertyInfo where + type AttrAllowedOps URIResponseHttpHeadersPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint URIResponseHttpHeadersPropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseHttpHeadersPropertyInfo = IsURIResponse + type AttrGetType URIResponseHttpHeadersPropertyInfo = (Maybe Soup.MessageHeaders.MessageHeaders) + type AttrLabel URIResponseHttpHeadersPropertyInfo = "http-headers" + type AttrOrigin URIResponseHttpHeadersPropertyInfo = URIResponse + attrGet _ = getURIResponseHttpHeaders + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "mime-type" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@mime-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIResponse #mimeType +@ +-} +getURIResponseMimeType :: (MonadIO m, IsURIResponse o) => o -> m T.Text +getURIResponseMimeType obj = liftIO $ checkUnexpectedNothing "getURIResponseMimeType" $ B.Properties.getObjectPropertyString obj "mime-type" + +#if ENABLE_OVERLOADING +data URIResponseMimeTypePropertyInfo +instance AttrInfo URIResponseMimeTypePropertyInfo where + type AttrAllowedOps URIResponseMimeTypePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint URIResponseMimeTypePropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseMimeTypePropertyInfo = IsURIResponse + type AttrGetType URIResponseMimeTypePropertyInfo = T.Text + type AttrLabel URIResponseMimeTypePropertyInfo = "mime-type" + type AttrOrigin URIResponseMimeTypePropertyInfo = URIResponse + attrGet _ = getURIResponseMimeType + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "status-code" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@status-code@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIResponse #statusCode +@ +-} +getURIResponseStatusCode :: (MonadIO m, IsURIResponse o) => o -> m Word32 +getURIResponseStatusCode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "status-code" + +#if ENABLE_OVERLOADING +data URIResponseStatusCodePropertyInfo +instance AttrInfo URIResponseStatusCodePropertyInfo where + type AttrAllowedOps URIResponseStatusCodePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint URIResponseStatusCodePropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseStatusCodePropertyInfo = IsURIResponse + type AttrGetType URIResponseStatusCodePropertyInfo = Word32 + type AttrLabel URIResponseStatusCodePropertyInfo = "status-code" + type AttrOrigin URIResponseStatusCodePropertyInfo = URIResponse + attrGet _ = getURIResponseStatusCode + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "suggested-filename" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@suggested-filename@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' uRIResponse #suggestedFilename +@ +-} +getURIResponseSuggestedFilename :: (MonadIO m, IsURIResponse o) => o -> m (Maybe T.Text) +getURIResponseSuggestedFilename obj = liftIO $ B.Properties.getObjectPropertyString obj "suggested-filename" + +#if ENABLE_OVERLOADING +data URIResponseSuggestedFilenamePropertyInfo +instance AttrInfo URIResponseSuggestedFilenamePropertyInfo where + type AttrAllowedOps URIResponseSuggestedFilenamePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint URIResponseSuggestedFilenamePropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseSuggestedFilenamePropertyInfo = IsURIResponse + type AttrGetType URIResponseSuggestedFilenamePropertyInfo = (Maybe T.Text) + type AttrLabel URIResponseSuggestedFilenamePropertyInfo = "suggested-filename" + type AttrOrigin URIResponseSuggestedFilenamePropertyInfo = URIResponse + attrGet _ = getURIResponseSuggestedFilename + 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' uRIResponse #uri +@ +-} +getURIResponseUri :: (MonadIO m, IsURIResponse o) => o -> m T.Text +getURIResponseUri obj = liftIO $ checkUnexpectedNothing "getURIResponseUri" $ B.Properties.getObjectPropertyString obj "uri" + +#if ENABLE_OVERLOADING +data URIResponseUriPropertyInfo +instance AttrInfo URIResponseUriPropertyInfo where + type AttrAllowedOps URIResponseUriPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint URIResponseUriPropertyInfo = (~) () + type AttrBaseTypeConstraint URIResponseUriPropertyInfo = IsURIResponse + type AttrGetType URIResponseUriPropertyInfo = T.Text + type AttrLabel URIResponseUriPropertyInfo = "uri" + type AttrOrigin URIResponseUriPropertyInfo = URIResponse + attrGet _ = getURIResponseUri + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList URIResponse +type instance O.AttributeList URIResponse = URIResponseAttributeList +type URIResponseAttributeList = ('[ '("contentLength", URIResponseContentLengthPropertyInfo), '("httpHeaders", URIResponseHttpHeadersPropertyInfo), '("mimeType", URIResponseMimeTypePropertyInfo), '("statusCode", URIResponseStatusCodePropertyInfo), '("suggestedFilename", URIResponseSuggestedFilenamePropertyInfo), '("uri", URIResponseUriPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +uRIResponseContentLength :: AttrLabelProxy "contentLength" +uRIResponseContentLength = AttrLabelProxy + +uRIResponseHttpHeaders :: AttrLabelProxy "httpHeaders" +uRIResponseHttpHeaders = AttrLabelProxy + +uRIResponseMimeType :: AttrLabelProxy "mimeType" +uRIResponseMimeType = AttrLabelProxy + +uRIResponseStatusCode :: AttrLabelProxy "statusCode" +uRIResponseStatusCode = AttrLabelProxy + +uRIResponseSuggestedFilename :: AttrLabelProxy "suggestedFilename" +uRIResponseSuggestedFilename = AttrLabelProxy + +uRIResponseUri :: AttrLabelProxy "uri" +uRIResponseUri = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList URIResponse = URIResponseSignalList +type URIResponseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method URIResponse::get_content_length +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_response_get_content_length" webkit_uri_response_get_content_length :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO Word64 + +{- | +Get the expected content length of the 'GI.WebKit2.Objects.URIResponse.URIResponse'. It can +be 0 if the server provided an incorrect or missing Content-Length. +-} +uRIResponseGetContentLength :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m Word64 + {- ^ __Returns:__ the expected content length of /@response@/. -} +uRIResponseGetContentLength response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_content_length response' + touchManagedPtr response + return result + +#if ENABLE_OVERLOADING +data URIResponseGetContentLengthMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetContentLengthMethodInfo a signature where + overloadedMethod _ = uRIResponseGetContentLength + +#endif + +-- method URIResponse::get_http_headers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Soup", name = "MessageHeaders"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_response_get_http_headers" webkit_uri_response_get_http_headers :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO (Ptr Soup.MessageHeaders.MessageHeaders) + +{- | +Get the HTTP headers of a 'GI.WebKit2.Objects.URIResponse.URIResponse' as a 'GI.Soup.Structs.MessageHeaders.MessageHeaders'. + +/Since: 2.6/ +-} +uRIResponseGetHttpHeaders :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m (Maybe Soup.MessageHeaders.MessageHeaders) + {- ^ __Returns:__ a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' with the HTTP headers of /@response@/ + or 'Nothing' if /@response@/ is not an HTTP response. -} +uRIResponseGetHttpHeaders response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_http_headers response' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Soup.MessageHeaders.MessageHeaders) result' + return result'' + touchManagedPtr response + return maybeResult + +#if ENABLE_OVERLOADING +data URIResponseGetHttpHeadersMethodInfo +instance (signature ~ (m (Maybe Soup.MessageHeaders.MessageHeaders)), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetHttpHeadersMethodInfo a signature where + overloadedMethod _ = uRIResponseGetHttpHeaders + +#endif + +-- method URIResponse::get_mime_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", 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_uri_response_get_mime_type" webkit_uri_response_get_mime_type :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +uRIResponseGetMimeType :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m T.Text + {- ^ __Returns:__ the MIME type of the 'GI.WebKit2.Objects.URIResponse.URIResponse' -} +uRIResponseGetMimeType response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_mime_type response' + checkUnexpectedReturnNULL "uRIResponseGetMimeType" result + result' <- cstringToText result + touchManagedPtr response + return result' + +#if ENABLE_OVERLOADING +data URIResponseGetMimeTypeMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetMimeTypeMethodInfo a signature where + overloadedMethod _ = uRIResponseGetMimeType + +#endif + +-- method URIResponse::get_status_code +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_response_get_status_code" webkit_uri_response_get_status_code :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO Word32 + +{- | +Get the status code of the 'GI.WebKit2.Objects.URIResponse.URIResponse' as returned by +the server. It will normally be a 'GI.Soup.Enums.KnownStatusCode', for +example 'GI.Soup.Enums.StatusOk', though the server can respond with any +unsigned integer. +-} +uRIResponseGetStatusCode :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m Word32 + {- ^ __Returns:__ the status code of /@response@/ -} +uRIResponseGetStatusCode response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_status_code response' + touchManagedPtr response + return result + +#if ENABLE_OVERLOADING +data URIResponseGetStatusCodeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetStatusCodeMethodInfo a signature where + overloadedMethod _ = uRIResponseGetStatusCode + +#endif + +-- method URIResponse::get_suggested_filename +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", 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_uri_response_get_suggested_filename" webkit_uri_response_get_suggested_filename :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO CString + +{- | +Get the suggested filename for /@response@/, as specified by +the \'Content-Disposition\' HTTP header, or 'Nothing' if it\'s not +present. +-} +uRIResponseGetSuggestedFilename :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the suggested filename or 'Nothing' if + the \'Content-Disposition\' HTTP header is not present. -} +uRIResponseGetSuggestedFilename response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_suggested_filename response' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr response + return maybeResult + +#if ENABLE_OVERLOADING +data URIResponseGetSuggestedFilenameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetSuggestedFilenameMethodInfo a signature where + overloadedMethod _ = uRIResponseGetSuggestedFilename + +#endif + +-- method URIResponse::get_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "response", argType = TInterface (Name {namespace = "WebKit2", name = "URIResponse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIResponse", 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_uri_response_get_uri" webkit_uri_response_get_uri :: + Ptr URIResponse -> -- response : TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +uRIResponseGetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsURIResponse a) => + a + {- ^ /@response@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse' -} + -> m T.Text + {- ^ __Returns:__ the uri of the 'GI.WebKit2.Objects.URIResponse.URIResponse' -} +uRIResponseGetUri response = liftIO $ do + response' <- unsafeManagedPtrCastPtr response + result <- webkit_uri_response_get_uri response' + checkUnexpectedReturnNULL "uRIResponseGetUri" result + result' <- cstringToText result + touchManagedPtr response + return result' + +#if ENABLE_OVERLOADING +data URIResponseGetUriMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURIResponse a) => O.MethodInfo URIResponseGetUriMethodInfo a signature where + overloadedMethod _ = uRIResponseGetUri + +#endif + + diff --git a/GI/WebKit2/Objects/URIResponse.hs-boot b/GI/WebKit2/Objects/URIResponse.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URIResponse.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.URIResponse 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 + +newtype URIResponse = URIResponse (ManagedPtr URIResponse) +instance GObject URIResponse where +class (GObject o, O.IsDescendantOf URIResponse o) => IsURIResponse o +instance (GObject o, O.IsDescendantOf URIResponse o) => IsURIResponse o +instance O.HasParentTypes URIResponse +#if ENABLE_OVERLOADING +data URIResponseContentLengthPropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseHttpHeadersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseMimeTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseStatusCodePropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseSuggestedFilenamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetContentLengthMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetHttpHeadersMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetMimeTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetStatusCodeMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetSuggestedFilenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data URIResponseGetUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/URISchemeRequest.hs b/GI/WebKit2/Objects/URISchemeRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URISchemeRequest.hs @@ -0,0 +1,414 @@ + + +{- | +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.URISchemeRequest + ( + +-- * Exported types + URISchemeRequest(..) , + IsURISchemeRequest , + toURISchemeRequest , + noURISchemeRequest , + + + -- * Methods +-- ** finish #method:finish# + +#if ENABLE_OVERLOADING + URISchemeRequestFinishMethodInfo , +#endif + uRISchemeRequestFinish , + + +-- ** finishError #method:finishError# + +#if ENABLE_OVERLOADING + URISchemeRequestFinishErrorMethodInfo , +#endif + uRISchemeRequestFinishError , + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + URISchemeRequestGetPathMethodInfo , +#endif + uRISchemeRequestGetPath , + + +-- ** getScheme #method:getScheme# + +#if ENABLE_OVERLOADING + URISchemeRequestGetSchemeMethodInfo , +#endif + uRISchemeRequestGetScheme , + + +-- ** getUri #method:getUri# + +#if ENABLE_OVERLOADING + URISchemeRequestGetUriMethodInfo , +#endif + uRISchemeRequestGetUri , + + +-- ** getWebView #method:getWebView# + +#if ENABLE_OVERLOADING + URISchemeRequestGetWebViewMethodInfo , +#endif + uRISchemeRequestGetWebView , + + + + + ) 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.Objects.InputStream as Gio.InputStream +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebView as WebKit2.WebView + +-- | Memory-managed wrapper type. +newtype URISchemeRequest = URISchemeRequest (ManagedPtr URISchemeRequest) +foreign import ccall "webkit_uri_scheme_request_get_type" + c_webkit_uri_scheme_request_get_type :: IO GType + +instance GObject URISchemeRequest where + gobjectType = c_webkit_uri_scheme_request_get_type + + +-- | Type class for types which can be safely cast to `URISchemeRequest`, for instance with `toURISchemeRequest`. +class (GObject o, O.IsDescendantOf URISchemeRequest o) => IsURISchemeRequest o +instance (GObject o, O.IsDescendantOf URISchemeRequest o) => IsURISchemeRequest o + +instance O.HasParentTypes URISchemeRequest +type instance O.ParentTypes URISchemeRequest = '[GObject.Object.Object] + +-- | Cast to `URISchemeRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toURISchemeRequest :: (MonadIO m, IsURISchemeRequest o) => o -> m URISchemeRequest +toURISchemeRequest = liftIO . unsafeCastTo URISchemeRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `URISchemeRequest`. +noURISchemeRequest :: Maybe URISchemeRequest +noURISchemeRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveURISchemeRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveURISchemeRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveURISchemeRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveURISchemeRequestMethod "finish" o = URISchemeRequestFinishMethodInfo + ResolveURISchemeRequestMethod "finishError" o = URISchemeRequestFinishErrorMethodInfo + ResolveURISchemeRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveURISchemeRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveURISchemeRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveURISchemeRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveURISchemeRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveURISchemeRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveURISchemeRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveURISchemeRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveURISchemeRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveURISchemeRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveURISchemeRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveURISchemeRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveURISchemeRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveURISchemeRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveURISchemeRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveURISchemeRequestMethod "getPath" o = URISchemeRequestGetPathMethodInfo + ResolveURISchemeRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveURISchemeRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveURISchemeRequestMethod "getScheme" o = URISchemeRequestGetSchemeMethodInfo + ResolveURISchemeRequestMethod "getUri" o = URISchemeRequestGetUriMethodInfo + ResolveURISchemeRequestMethod "getWebView" o = URISchemeRequestGetWebViewMethodInfo + ResolveURISchemeRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveURISchemeRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveURISchemeRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveURISchemeRequestMethod t URISchemeRequest, O.MethodInfo info URISchemeRequest p) => OL.IsLabel t (URISchemeRequest -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList URISchemeRequest +type instance O.AttributeList URISchemeRequest = URISchemeRequestAttributeList +type URISchemeRequestAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList URISchemeRequest = URISchemeRequestSignalList +type URISchemeRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method URISchemeRequest::finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream to read the contents of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the stream or -1 if not known", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the content type of the stream or %NULL if not known", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_scheme_request_finish" webkit_uri_scheme_request_finish :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + Ptr Gio.InputStream.InputStream -> -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Int64 -> -- stream_length : TBasicType TInt64 + CString -> -- mime_type : TBasicType TUTF8 + IO () + +{- | +Finish a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' by setting the contents of the request and its mime type. +-} +uRISchemeRequestFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a, Gio.InputStream.IsInputStream b) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> b + {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' to read the contents of the request -} + -> Int64 + {- ^ /@streamLength@/: the length of the stream or -1 if not known -} + -> Maybe (T.Text) + {- ^ /@mimeType@/: the content type of the stream or 'Nothing' if not known -} + -> m () +uRISchemeRequestFinish request stream streamLength mimeType = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + stream' <- unsafeManagedPtrCastPtr stream + maybeMimeType <- case mimeType of + Nothing -> return nullPtr + Just jMimeType -> do + jMimeType' <- textToCString jMimeType + return jMimeType' + webkit_uri_scheme_request_finish request' stream' streamLength maybeMimeType + touchManagedPtr request + touchManagedPtr stream + freeMem maybeMimeType + return () + +#if ENABLE_OVERLOADING +data URISchemeRequestFinishMethodInfo +instance (signature ~ (b -> Int64 -> Maybe (T.Text) -> m ()), MonadIO m, IsURISchemeRequest a, Gio.InputStream.IsInputStream b) => O.MethodInfo URISchemeRequestFinishMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestFinish + +#endif + +-- method URISchemeRequest::finish_error +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError that will be passed to the #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_scheme_request_finish_error" webkit_uri_scheme_request_finish_error :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + Ptr GError -> -- error : TError + IO () + +{- | +Finish a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' with a 'GError'. + +/Since: 2.2/ +-} +uRISchemeRequestFinishError :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> GError + {- ^ /@error@/: a 'GError' that will be passed to the 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +uRISchemeRequestFinishError request error_ = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + error_' <- unsafeManagedPtrGetPtr error_ + webkit_uri_scheme_request_finish_error request' error_' + touchManagedPtr request + touchManagedPtr error_ + return () + +#if ENABLE_OVERLOADING +data URISchemeRequestFinishErrorMethodInfo +instance (signature ~ (GError -> m ()), MonadIO m, IsURISchemeRequest a) => O.MethodInfo URISchemeRequestFinishErrorMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestFinishError + +#endif + +-- method URISchemeRequest::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", 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_uri_scheme_request_get_path" webkit_uri_scheme_request_get_path :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + IO CString + +{- | +Get the URI path of /@request@/ +-} +uRISchemeRequestGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> m T.Text + {- ^ __Returns:__ the URI path of /@request@/ -} +uRISchemeRequestGetPath request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_scheme_request_get_path request' + checkUnexpectedReturnNULL "uRISchemeRequestGetPath" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URISchemeRequestGetPathMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURISchemeRequest a) => O.MethodInfo URISchemeRequestGetPathMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestGetPath + +#endif + +-- method URISchemeRequest::get_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", 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_uri_scheme_request_get_scheme" webkit_uri_scheme_request_get_scheme :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + IO CString + +{- | +Get the URI scheme of /@request@/ +-} +uRISchemeRequestGetScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> m T.Text + {- ^ __Returns:__ the URI scheme of /@request@/ -} +uRISchemeRequestGetScheme request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_scheme_request_get_scheme request' + checkUnexpectedReturnNULL "uRISchemeRequestGetScheme" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URISchemeRequestGetSchemeMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURISchemeRequest a) => O.MethodInfo URISchemeRequestGetSchemeMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestGetScheme + +#endif + +-- method URISchemeRequest::get_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", 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_uri_scheme_request_get_uri" webkit_uri_scheme_request_get_uri :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + IO CString + +{- | +Get the URI of /@request@/ +-} +uRISchemeRequestGetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> m T.Text + {- ^ __Returns:__ the full URI of /@request@/ -} +uRISchemeRequestGetUri request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_scheme_request_get_uri request' + checkUnexpectedReturnNULL "uRISchemeRequestGetUri" result + result' <- cstringToText result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URISchemeRequestGetUriMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsURISchemeRequest a) => O.MethodInfo URISchemeRequestGetUriMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestGetUri + +#endif + +-- method URISchemeRequest::get_web_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_uri_scheme_request_get_web_view" webkit_uri_scheme_request_get_web_view :: + Ptr URISchemeRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequest"}) + IO (Ptr WebKit2.WebView.WebView) + +{- | +Get the 'GI.WebKit2.Objects.WebView.WebView' that initiated the request. +-} +uRISchemeRequestGetWebView :: + (B.CallStack.HasCallStack, MonadIO m, IsURISchemeRequest a) => + a + {- ^ /@request@/: a 'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' -} + -> m WebKit2.WebView.WebView + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebView.WebView' that initiated /@request@/. -} +uRISchemeRequestGetWebView request = liftIO $ do + request' <- unsafeManagedPtrCastPtr request + result <- webkit_uri_scheme_request_get_web_view request' + checkUnexpectedReturnNULL "uRISchemeRequestGetWebView" result + result' <- (newObject WebKit2.WebView.WebView) result + touchManagedPtr request + return result' + +#if ENABLE_OVERLOADING +data URISchemeRequestGetWebViewMethodInfo +instance (signature ~ (m WebKit2.WebView.WebView), MonadIO m, IsURISchemeRequest a) => O.MethodInfo URISchemeRequestGetWebViewMethodInfo a signature where + overloadedMethod _ = uRISchemeRequestGetWebView + +#endif + + diff --git a/GI/WebKit2/Objects/URISchemeRequest.hs-boot b/GI/WebKit2/Objects/URISchemeRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/URISchemeRequest.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.URISchemeRequest 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 + +newtype URISchemeRequest = URISchemeRequest (ManagedPtr URISchemeRequest) +instance GObject URISchemeRequest where +class (GObject o, O.IsDescendantOf URISchemeRequest o) => IsURISchemeRequest o +instance (GObject o, O.IsDescendantOf URISchemeRequest o) => IsURISchemeRequest o +instance O.HasParentTypes URISchemeRequest +#if ENABLE_OVERLOADING +data URISchemeRequestFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data URISchemeRequestFinishErrorMethodInfo +#endif +#if ENABLE_OVERLOADING +data URISchemeRequestGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data URISchemeRequestGetSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data URISchemeRequestGetUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data URISchemeRequestGetWebViewMethodInfo +#endif diff --git a/GI/WebKit2/Objects/UserContentFilterStore.hs b/GI/WebKit2/Objects/UserContentFilterStore.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserContentFilterStore.hs @@ -0,0 +1,942 @@ + + +{- | +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.UserContentFilterStore + ( + +-- * Exported types + UserContentFilterStore(..) , + IsUserContentFilterStore , + toUserContentFilterStore , + noUserContentFilterStore , + + + -- * Methods +-- ** fetchIdentifiers #method:fetchIdentifiers# + +#if ENABLE_OVERLOADING + UserContentFilterStoreFetchIdentifiersMethodInfo, +#endif + userContentFilterStoreFetchIdentifiers , + + +-- ** fetchIdentifiersFinish #method:fetchIdentifiersFinish# + +#if ENABLE_OVERLOADING + UserContentFilterStoreFetchIdentifiersFinishMethodInfo, +#endif + userContentFilterStoreFetchIdentifiersFinish, + + +-- ** getPath #method:getPath# + +#if ENABLE_OVERLOADING + UserContentFilterStoreGetPathMethodInfo , +#endif + userContentFilterStoreGetPath , + + +-- ** load #method:load# + +#if ENABLE_OVERLOADING + UserContentFilterStoreLoadMethodInfo , +#endif + userContentFilterStoreLoad , + + +-- ** loadFinish #method:loadFinish# + +#if ENABLE_OVERLOADING + UserContentFilterStoreLoadFinishMethodInfo, +#endif + userContentFilterStoreLoadFinish , + + +-- ** new #method:new# + + userContentFilterStoreNew , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + UserContentFilterStoreRemoveMethodInfo , +#endif + userContentFilterStoreRemove , + + +-- ** removeFinish #method:removeFinish# + +#if ENABLE_OVERLOADING + UserContentFilterStoreRemoveFinishMethodInfo, +#endif + userContentFilterStoreRemoveFinish , + + +-- ** save #method:save# + +#if ENABLE_OVERLOADING + UserContentFilterStoreSaveMethodInfo , +#endif + userContentFilterStoreSave , + + +-- ** saveFinish #method:saveFinish# + +#if ENABLE_OVERLOADING + UserContentFilterStoreSaveFinishMethodInfo, +#endif + userContentFilterStoreSaveFinish , + + +-- ** saveFromFile #method:saveFromFile# + +#if ENABLE_OVERLOADING + UserContentFilterStoreSaveFromFileMethodInfo, +#endif + userContentFilterStoreSaveFromFile , + + +-- ** saveFromFileFinish #method:saveFromFileFinish# + +#if ENABLE_OVERLOADING + UserContentFilterStoreSaveFromFileFinishMethodInfo, +#endif + userContentFilterStoreSaveFromFileFinish, + + + + + -- * Properties +-- ** path #attr:path# +{- | The directory used for filter storage. This path is used as the base +directory where user content filters are stored on disk. + +/Since: 2.24/ +-} +#if ENABLE_OVERLOADING + UserContentFilterStorePathPropertyInfo , +#endif + constructUserContentFilterStorePath , + getUserContentFilterStorePath , +#if ENABLE_OVERLOADING + userContentFilterStorePath , +#endif + + + + + ) 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.GLib.Structs.Bytes as GLib.Bytes +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserContentFilter as WebKit2.UserContentFilter + +-- | Memory-managed wrapper type. +newtype UserContentFilterStore = UserContentFilterStore (ManagedPtr UserContentFilterStore) +foreign import ccall "webkit_user_content_filter_store_get_type" + c_webkit_user_content_filter_store_get_type :: IO GType + +instance GObject UserContentFilterStore where + gobjectType = c_webkit_user_content_filter_store_get_type + + +-- | Type class for types which can be safely cast to `UserContentFilterStore`, for instance with `toUserContentFilterStore`. +class (GObject o, O.IsDescendantOf UserContentFilterStore o) => IsUserContentFilterStore o +instance (GObject o, O.IsDescendantOf UserContentFilterStore o) => IsUserContentFilterStore o + +instance O.HasParentTypes UserContentFilterStore +type instance O.ParentTypes UserContentFilterStore = '[GObject.Object.Object] + +-- | Cast to `UserContentFilterStore`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toUserContentFilterStore :: (MonadIO m, IsUserContentFilterStore o) => o -> m UserContentFilterStore +toUserContentFilterStore = liftIO . unsafeCastTo UserContentFilterStore + +-- | A convenience alias for `Nothing` :: `Maybe` `UserContentFilterStore`. +noUserContentFilterStore :: Maybe UserContentFilterStore +noUserContentFilterStore = Nothing + +#if ENABLE_OVERLOADING +type family ResolveUserContentFilterStoreMethod (t :: Symbol) (o :: *) :: * where + ResolveUserContentFilterStoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveUserContentFilterStoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveUserContentFilterStoreMethod "fetchIdentifiers" o = UserContentFilterStoreFetchIdentifiersMethodInfo + ResolveUserContentFilterStoreMethod "fetchIdentifiersFinish" o = UserContentFilterStoreFetchIdentifiersFinishMethodInfo + ResolveUserContentFilterStoreMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveUserContentFilterStoreMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveUserContentFilterStoreMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveUserContentFilterStoreMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveUserContentFilterStoreMethod "load" o = UserContentFilterStoreLoadMethodInfo + ResolveUserContentFilterStoreMethod "loadFinish" o = UserContentFilterStoreLoadFinishMethodInfo + ResolveUserContentFilterStoreMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveUserContentFilterStoreMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveUserContentFilterStoreMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveUserContentFilterStoreMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveUserContentFilterStoreMethod "remove" o = UserContentFilterStoreRemoveMethodInfo + ResolveUserContentFilterStoreMethod "removeFinish" o = UserContentFilterStoreRemoveFinishMethodInfo + ResolveUserContentFilterStoreMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveUserContentFilterStoreMethod "save" o = UserContentFilterStoreSaveMethodInfo + ResolveUserContentFilterStoreMethod "saveFinish" o = UserContentFilterStoreSaveFinishMethodInfo + ResolveUserContentFilterStoreMethod "saveFromFile" o = UserContentFilterStoreSaveFromFileMethodInfo + ResolveUserContentFilterStoreMethod "saveFromFileFinish" o = UserContentFilterStoreSaveFromFileFinishMethodInfo + ResolveUserContentFilterStoreMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveUserContentFilterStoreMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveUserContentFilterStoreMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveUserContentFilterStoreMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveUserContentFilterStoreMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveUserContentFilterStoreMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveUserContentFilterStoreMethod "getPath" o = UserContentFilterStoreGetPathMethodInfo + ResolveUserContentFilterStoreMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveUserContentFilterStoreMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveUserContentFilterStoreMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveUserContentFilterStoreMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveUserContentFilterStoreMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserContentFilterStoreMethod t UserContentFilterStore, O.MethodInfo info UserContentFilterStore p) => OL.IsLabel t (UserContentFilterStore -> 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 + +-- VVV Prop "path" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' userContentFilterStore #path +@ +-} +getUserContentFilterStorePath :: (MonadIO m, IsUserContentFilterStore o) => o -> m T.Text +getUserContentFilterStorePath obj = liftIO $ checkUnexpectedNothing "getUserContentFilterStorePath" $ B.Properties.getObjectPropertyString obj "path" + +{- | +Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructUserContentFilterStorePath :: (IsUserContentFilterStore o) => T.Text -> IO (GValueConstruct o) +constructUserContentFilterStorePath val = B.Properties.constructObjectPropertyString "path" (Just val) + +#if ENABLE_OVERLOADING +data UserContentFilterStorePathPropertyInfo +instance AttrInfo UserContentFilterStorePathPropertyInfo where + type AttrAllowedOps UserContentFilterStorePathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint UserContentFilterStorePathPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint UserContentFilterStorePathPropertyInfo = IsUserContentFilterStore + type AttrGetType UserContentFilterStorePathPropertyInfo = T.Text + type AttrLabel UserContentFilterStorePathPropertyInfo = "path" + type AttrOrigin UserContentFilterStorePathPropertyInfo = UserContentFilterStore + attrGet _ = getUserContentFilterStorePath + attrSet _ = undefined + attrConstruct _ = constructUserContentFilterStorePath + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserContentFilterStore +type instance O.AttributeList UserContentFilterStore = UserContentFilterStoreAttributeList +type UserContentFilterStoreAttributeList = ('[ '("path", UserContentFilterStorePathPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +userContentFilterStorePath :: AttrLabelProxy "path" +userContentFilterStorePath = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList UserContentFilterStore = UserContentFilterStoreSignalList +type UserContentFilterStoreSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method UserContentFilterStore::new +-- method type : Constructor +-- Args : [Arg {argCName = "storage_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path where data for filters will be stored on disk", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_new" webkit_user_content_filter_store_new :: + CString -> -- storage_path : TBasicType TUTF8 + IO (Ptr UserContentFilterStore) + +{- | +Create a new 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' to manipulate filters stored at /@storagePath@/. +The path must point to a local filesystem, and will be created if needed. + +/Since: 2.24/ +-} +userContentFilterStoreNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@storagePath@/: path where data for filters will be stored on disk -} + -> m UserContentFilterStore + {- ^ __Returns:__ a newly created 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} +userContentFilterStoreNew storagePath = liftIO $ do + storagePath' <- textToCString storagePath + result <- webkit_user_content_filter_store_new storagePath' + checkUnexpectedReturnNULL "userContentFilterStoreNew" result + result' <- (wrapObject UserContentFilterStore) result + freeMem storagePath' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserContentFilterStore::fetch_identifiers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", 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 removal is completed", 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 the 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_user_content_filter_store_fetch_identifiers" webkit_user_content_filter_store_fetch_identifiers :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + 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 retrieve a list of the identifiers for all the stored filters. + +When the operation is finished, /@callback@/ will be invoked, which then can use +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreFetchIdentifiersFinish' to obtain the list of +filter identifiers. + +/Since: 2.24/ +-} +userContentFilterStoreFetchIdentifiers :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> 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 removal is completed -} + -> m () +userContentFilterStoreFetchIdentifiers store cancellable callback = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + 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_user_content_filter_store_fetch_identifiers store' maybeCancellable maybeCallback userData + touchManagedPtr store + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data UserContentFilterStoreFetchIdentifiersMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => O.MethodInfo UserContentFilterStoreFetchIdentifiersMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreFetchIdentifiers + +#endif + +-- method UserContentFilterStore::fetch_identifiers_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_fetch_identifiers_finish" webkit_user_content_filter_store_fetch_identifiers_finish :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + IO (Ptr CString) + +{- | +Finishes an asynchronous fetch of the list of identifiers for the stored filters previously +started with 'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreFetchIdentifiers'. + +/Since: 2.24/ +-} +userContentFilterStoreFetchIdentifiersFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m [T.Text] + {- ^ __Returns:__ a 'Nothing'-terminated list of filter identifiers. -} +userContentFilterStoreFetchIdentifiersFinish store result_ = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result_' <- unsafeManagedPtrCastPtr result_ + result <- webkit_user_content_filter_store_fetch_identifiers_finish store' result_' + checkUnexpectedReturnNULL "userContentFilterStoreFetchIdentifiersFinish" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr store + touchManagedPtr result_ + return result' + +#if ENABLE_OVERLOADING +data UserContentFilterStoreFetchIdentifiersFinishMethodInfo +instance (signature ~ (b -> m [T.Text]), MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo UserContentFilterStoreFetchIdentifiersFinishMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreFetchIdentifiersFinish + +#endif + +-- method UserContentFilterStore::get_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", 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_user_content_filter_store_get_path" webkit_user_content_filter_store_get_path :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 2.24/ +-} +userContentFilterStoreGetPath :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> m T.Text + {- ^ __Returns:__ The storage path for user content filters. -} +userContentFilterStoreGetPath store = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result <- webkit_user_content_filter_store_get_path store' + checkUnexpectedReturnNULL "userContentFilterStoreGetPath" result + result' <- cstringToText result + touchManagedPtr store + return result' + +#if ENABLE_OVERLOADING +data UserContentFilterStoreGetPathMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsUserContentFilterStore a) => O.MethodInfo UserContentFilterStoreGetPathMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreGetPath + +#endif + +-- method UserContentFilterStore::load +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filter identifier", 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 load is completed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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 the 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_user_content_filter_store_load" webkit_user_content_filter_store_load :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + CString -> -- identifier : TBasicType TUTF8 + 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 load a content filter given its /@identifier@/. The filter must have been +previously stored using 'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSave'. + +When the operation is finished, /@callback@/ will be invoked, which then can use +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreLoadFinish' to obtain the resulting filter. + +/Since: 2.24/ +-} +userContentFilterStoreLoad :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> T.Text + {- ^ /@identifier@/: a filter identifier -} + -> 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 load is completed -} + -> m () +userContentFilterStoreLoad store identifier cancellable callback = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + identifier' <- textToCString identifier + 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_user_content_filter_store_load store' identifier' maybeCancellable maybeCallback userData + touchManagedPtr store + whenJust cancellable touchManagedPtr + freeMem identifier' + return () + +#if ENABLE_OVERLOADING +data UserContentFilterStoreLoadMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => O.MethodInfo UserContentFilterStoreLoadMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreLoad + +#endif + +-- method UserContentFilterStore::load_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_load_finish" webkit_user_content_filter_store_load_finish :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.UserContentFilter.UserContentFilter) + +{- | +Finishes an asynchronous filter load previously started with +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreLoad'. + +/Since: 2.24/ +-} +userContentFilterStoreLoadFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.UserContentFilter.UserContentFilter + {- ^ __Returns:__ a 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter', or 'Nothing' if the load failed /(Can throw 'Data.GI.Base.GError.GError')/ -} +userContentFilterStoreLoadFinish store result_ = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_user_content_filter_store_load_finish store' result_' + checkUnexpectedReturnNULL "userContentFilterStoreLoadFinish" result + result' <- (wrapBoxed WebKit2.UserContentFilter.UserContentFilter) result + touchManagedPtr store + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data UserContentFilterStoreLoadFinishMethodInfo +instance (signature ~ (b -> m WebKit2.UserContentFilter.UserContentFilter), MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo UserContentFilterStoreLoadFinishMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreLoadFinish + +#endif + +-- method UserContentFilterStore::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filter identifier", 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 removal is completed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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 the 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_user_content_filter_store_remove" webkit_user_content_filter_store_remove :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + CString -> -- identifier : TBasicType TUTF8 + 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 remove a content filter given its /@identifier@/. + +When the operation is finished, /@callback@/ will be invoked, which then can use +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreRemoveFinish' to check whether the removal was +successful. + +/Since: 2.24/ +-} +userContentFilterStoreRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> T.Text + {- ^ /@identifier@/: a filter identifier -} + -> 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 removal is completed -} + -> m () +userContentFilterStoreRemove store identifier cancellable callback = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + identifier' <- textToCString identifier + 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_user_content_filter_store_remove store' identifier' maybeCancellable maybeCallback userData + touchManagedPtr store + whenJust cancellable touchManagedPtr + freeMem identifier' + return () + +#if ENABLE_OVERLOADING +data UserContentFilterStoreRemoveMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => O.MethodInfo UserContentFilterStoreRemoveMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreRemove + +#endif + +-- method UserContentFilterStore::remove_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_remove_finish" webkit_user_content_filter_store_remove_finish :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finishes an asynchronous filter removal previously started with +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreRemove'. + +/Since: 2.24/ +-} +userContentFilterStoreRemoveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +userContentFilterStoreRemoveFinish store result_ = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_user_content_filter_store_remove_finish store' result_' + touchManagedPtr store + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data UserContentFilterStoreRemoveFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo UserContentFilterStoreRemoveFinishMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreRemoveFinish + +#endif + +-- method UserContentFilterStore::save +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string used to identify the saved filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GBytes containing the rule set in JSON format", 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 saving is completed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, 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 the 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_user_content_filter_store_save" webkit_user_content_filter_store_save :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + CString -> -- identifier : TBasicType TUTF8 + Ptr GLib.Bytes.Bytes -> -- source : TInterface (Name {namespace = "GLib", name = "Bytes"}) + 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 save a content filter from a source rule set in the +. + +The /@identifier@/ can be used afterwards to refer to the filter when using +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreRemove' and 'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreLoad'. +When the /@identifier@/ has been used in the past, the new filter source will replace +the one saved beforehand for the same identifier. + +When the operation is finished, /@callback@/ will be invoked, which then can use +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSaveFinish' to obtain the resulting filter. + +/Since: 2.24/ +-} +userContentFilterStoreSave :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> T.Text + {- ^ /@identifier@/: a string used to identify the saved filter -} + -> GLib.Bytes.Bytes + {- ^ /@source@/: 'GI.GLib.Structs.Bytes.Bytes' containing the rule set in JSON format -} + -> 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 saving is completed -} + -> m () +userContentFilterStoreSave store identifier source cancellable callback = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + identifier' <- textToCString identifier + source' <- unsafeManagedPtrGetPtr source + 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_user_content_filter_store_save store' identifier' source' maybeCancellable maybeCallback userData + touchManagedPtr store + touchManagedPtr source + whenJust cancellable touchManagedPtr + freeMem identifier' + return () + +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveMethodInfo +instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.Cancellable.IsCancellable b) => O.MethodInfo UserContentFilterStoreSaveMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreSave + +#endif + +-- method UserContentFilterStore::save_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_save_finish" webkit_user_content_filter_store_save_finish :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.UserContentFilter.UserContentFilter) + +{- | +Finishes an asynchronous filter save previously started with +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSave'. + +/Since: 2.24/ +-} +userContentFilterStoreSaveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.UserContentFilter.UserContentFilter + {- ^ __Returns:__ a 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter', or 'Nothing' if saving failed /(Can throw 'Data.GI.Base.GError.GError')/ -} +userContentFilterStoreSaveFinish store result_ = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_user_content_filter_store_save_finish store' result_' + checkUnexpectedReturnNULL "userContentFilterStoreSaveFinish" result + result' <- (wrapBoxed WebKit2.UserContentFilter.UserContentFilter) result + touchManagedPtr store + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFinishMethodInfo +instance (signature ~ (b -> m WebKit2.UserContentFilter.UserContentFilter), MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo UserContentFilterStoreSaveFinishMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreSaveFinish + +#endif + +-- method UserContentFilterStore::save_from_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string used to identify the saved filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile containing the rule set in JSON format", 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 saving is completed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, 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 the 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_user_content_filter_store_save_from_file" webkit_user_content_filter_store_save_from_file :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + CString -> -- identifier : TBasicType TUTF8 + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + 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 save a content filter from the contents of a file, which must be +native to the platform, as checked by 'GI.Gio.Interfaces.File.fileIsNative'. See +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSave' for more details. + +When the operation is finished, /@callback@/ will be invoked, which then can use +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSaveFinish' to obtain the resulting filter. + +/Since: 2.24/ +-} +userContentFilterStoreSaveFromFile :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> T.Text + {- ^ /@identifier@/: a string used to identify the saved filter -} + -> b + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File' containing the rule set in JSON format -} + -> Maybe (c) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when saving is completed -} + -> m () +userContentFilterStoreSaveFromFile store identifier file cancellable callback = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + identifier' <- textToCString identifier + file' <- unsafeManagedPtrCastPtr file + 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_user_content_filter_store_save_from_file store' identifier' file' maybeCancellable maybeCallback userData + touchManagedPtr store + touchManagedPtr file + whenJust cancellable touchManagedPtr + freeMem identifier' + return () + +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFromFileMethodInfo +instance (signature ~ (T.Text -> b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsUserContentFilterStore a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo UserContentFilterStoreSaveFromFileMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreSaveFromFile + +#endif + +-- method UserContentFilterStore::save_from_file_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentFilterStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_store_save_from_file_finish" webkit_user_content_filter_store_save_from_file_finish :: + Ptr UserContentFilterStore -> -- store : TInterface (Name {namespace = "WebKit2", name = "UserContentFilterStore"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.UserContentFilter.UserContentFilter) + +{- | +Finishes and asynchronous filter save previously started with +'GI.WebKit2.Objects.UserContentFilterStore.userContentFilterStoreSaveFromFile'. + +/Since: 2.24/ +-} +userContentFilterStoreSaveFromFileFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@store@/: a 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.UserContentFilter.UserContentFilter + {- ^ __Returns:__ a 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter', or 'Nothing' if saving failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} +userContentFilterStoreSaveFromFileFinish store result_ = liftIO $ do + store' <- unsafeManagedPtrCastPtr store + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_user_content_filter_store_save_from_file_finish store' result_' + checkUnexpectedReturnNULL "userContentFilterStoreSaveFromFileFinish" result + result' <- (wrapBoxed WebKit2.UserContentFilter.UserContentFilter) result + touchManagedPtr store + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFromFileFinishMethodInfo +instance (signature ~ (b -> m WebKit2.UserContentFilter.UserContentFilter), MonadIO m, IsUserContentFilterStore a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo UserContentFilterStoreSaveFromFileFinishMethodInfo a signature where + overloadedMethod _ = userContentFilterStoreSaveFromFileFinish + +#endif + + diff --git a/GI/WebKit2/Objects/UserContentFilterStore.hs-boot b/GI/WebKit2/Objects/UserContentFilterStore.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserContentFilterStore.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.UserContentFilterStore 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 + +newtype UserContentFilterStore = UserContentFilterStore (ManagedPtr UserContentFilterStore) +instance GObject UserContentFilterStore where +class (GObject o, O.IsDescendantOf UserContentFilterStore o) => IsUserContentFilterStore o +instance (GObject o, O.IsDescendantOf UserContentFilterStore o) => IsUserContentFilterStore o +instance O.HasParentTypes UserContentFilterStore +#if ENABLE_OVERLOADING +data UserContentFilterStorePathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreFetchIdentifiersMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreFetchIdentifiersFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreGetPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreLoadMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreLoadFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreRemoveFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFromFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterStoreSaveFromFileFinishMethodInfo +#endif diff --git a/GI/WebKit2/Objects/UserContentManager.hs b/GI/WebKit2/Objects/UserContentManager.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserContentManager.hs @@ -0,0 +1,844 @@ + + +{- | +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.UserContentManager + ( + +-- * Exported types + UserContentManager(..) , + IsUserContentManager , + toUserContentManager , + noUserContentManager , + + + -- * Methods +-- ** addFilter #method:addFilter# + +#if ENABLE_OVERLOADING + UserContentManagerAddFilterMethodInfo , +#endif + userContentManagerAddFilter , + + +-- ** addScript #method:addScript# + +#if ENABLE_OVERLOADING + UserContentManagerAddScriptMethodInfo , +#endif + userContentManagerAddScript , + + +-- ** addStyleSheet #method:addStyleSheet# + +#if ENABLE_OVERLOADING + UserContentManagerAddStyleSheetMethodInfo, +#endif + userContentManagerAddStyleSheet , + + +-- ** new #method:new# + + userContentManagerNew , + + +-- ** registerScriptMessageHandler #method:registerScriptMessageHandler# + +#if ENABLE_OVERLOADING + UserContentManagerRegisterScriptMessageHandlerMethodInfo, +#endif + userContentManagerRegisterScriptMessageHandler, + + +-- ** registerScriptMessageHandlerInWorld #method:registerScriptMessageHandlerInWorld# + +#if ENABLE_OVERLOADING + UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo, +#endif + userContentManagerRegisterScriptMessageHandlerInWorld, + + +-- ** removeAllFilters #method:removeAllFilters# + +#if ENABLE_OVERLOADING + UserContentManagerRemoveAllFiltersMethodInfo, +#endif + userContentManagerRemoveAllFilters , + + +-- ** removeAllScripts #method:removeAllScripts# + +#if ENABLE_OVERLOADING + UserContentManagerRemoveAllScriptsMethodInfo, +#endif + userContentManagerRemoveAllScripts , + + +-- ** removeAllStyleSheets #method:removeAllStyleSheets# + +#if ENABLE_OVERLOADING + UserContentManagerRemoveAllStyleSheetsMethodInfo, +#endif + userContentManagerRemoveAllStyleSheets , + + +-- ** removeFilter #method:removeFilter# + +#if ENABLE_OVERLOADING + UserContentManagerRemoveFilterMethodInfo, +#endif + userContentManagerRemoveFilter , + + +-- ** unregisterScriptMessageHandler #method:unregisterScriptMessageHandler# + +#if ENABLE_OVERLOADING + UserContentManagerUnregisterScriptMessageHandlerMethodInfo, +#endif + userContentManagerUnregisterScriptMessageHandler, + + +-- ** unregisterScriptMessageHandlerInWorld #method:unregisterScriptMessageHandlerInWorld# + +#if ENABLE_OVERLOADING + UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo, +#endif + userContentManagerUnregisterScriptMessageHandlerInWorld, + + + + + -- * Signals +-- ** scriptMessageReceived #signal:scriptMessageReceived# + + C_UserContentManagerScriptMessageReceivedCallback, + UserContentManagerScriptMessageReceivedCallback, +#if ENABLE_OVERLOADING + UserContentManagerScriptMessageReceivedSignalInfo, +#endif + afterUserContentManagerScriptMessageReceived, + genClosure_UserContentManagerScriptMessageReceived, + mk_UserContentManagerScriptMessageReceivedCallback, + noUserContentManagerScriptMessageReceivedCallback, + onUserContentManagerScriptMessageReceived, + wrap_UserContentManagerScriptMessageReceivedCallback, + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Structs.JavascriptResult as WebKit2.JavascriptResult +import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserContentFilter as WebKit2.UserContentFilter +import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserScript as WebKit2.UserScript +import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserStyleSheet as WebKit2.UserStyleSheet + +-- | Memory-managed wrapper type. +newtype UserContentManager = UserContentManager (ManagedPtr UserContentManager) +foreign import ccall "webkit_user_content_manager_get_type" + c_webkit_user_content_manager_get_type :: IO GType + +instance GObject UserContentManager where + gobjectType = c_webkit_user_content_manager_get_type + + +-- | Type class for types which can be safely cast to `UserContentManager`, for instance with `toUserContentManager`. +class (GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o +instance (GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o + +instance O.HasParentTypes UserContentManager +type instance O.ParentTypes UserContentManager = '[GObject.Object.Object] + +-- | Cast to `UserContentManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toUserContentManager :: (MonadIO m, IsUserContentManager o) => o -> m UserContentManager +toUserContentManager = liftIO . unsafeCastTo UserContentManager + +-- | A convenience alias for `Nothing` :: `Maybe` `UserContentManager`. +noUserContentManager :: Maybe UserContentManager +noUserContentManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveUserContentManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveUserContentManagerMethod "addFilter" o = UserContentManagerAddFilterMethodInfo + ResolveUserContentManagerMethod "addScript" o = UserContentManagerAddScriptMethodInfo + ResolveUserContentManagerMethod "addStyleSheet" o = UserContentManagerAddStyleSheetMethodInfo + ResolveUserContentManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveUserContentManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveUserContentManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveUserContentManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveUserContentManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveUserContentManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveUserContentManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveUserContentManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveUserContentManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveUserContentManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveUserContentManagerMethod "registerScriptMessageHandler" o = UserContentManagerRegisterScriptMessageHandlerMethodInfo + ResolveUserContentManagerMethod "registerScriptMessageHandlerInWorld" o = UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo + ResolveUserContentManagerMethod "removeAllFilters" o = UserContentManagerRemoveAllFiltersMethodInfo + ResolveUserContentManagerMethod "removeAllScripts" o = UserContentManagerRemoveAllScriptsMethodInfo + ResolveUserContentManagerMethod "removeAllStyleSheets" o = UserContentManagerRemoveAllStyleSheetsMethodInfo + ResolveUserContentManagerMethod "removeFilter" o = UserContentManagerRemoveFilterMethodInfo + ResolveUserContentManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveUserContentManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveUserContentManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveUserContentManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveUserContentManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveUserContentManagerMethod "unregisterScriptMessageHandler" o = UserContentManagerUnregisterScriptMessageHandlerMethodInfo + ResolveUserContentManagerMethod "unregisterScriptMessageHandlerInWorld" o = UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo + ResolveUserContentManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveUserContentManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveUserContentManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveUserContentManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveUserContentManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveUserContentManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveUserContentManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserContentManagerMethod t UserContentManager, O.MethodInfo info UserContentManager p) => OL.IsLabel t (UserContentManager -> 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 UserContentManager::script-message-received +{- | +This signal is emitted when JavaScript in a web view calls +\window.webkit.messageHandlers.<name>.@/postMessage()/@\<\/code>, after registering +\<name>\<\/code> using +'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler' + +/Since: 2.8/ +-} +type UserContentManagerScriptMessageReceivedCallback = + WebKit2.JavascriptResult.JavascriptResult + {- ^ /@jsResult@/: the 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' holding the value received from the JavaScript world. -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `UserContentManagerScriptMessageReceivedCallback`@. +noUserContentManagerScriptMessageReceivedCallback :: Maybe UserContentManagerScriptMessageReceivedCallback +noUserContentManagerScriptMessageReceivedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_UserContentManagerScriptMessageReceivedCallback = + Ptr () -> -- object + Ptr WebKit2.JavascriptResult.JavascriptResult -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_UserContentManagerScriptMessageReceivedCallback`. +foreign import ccall "wrapper" + mk_UserContentManagerScriptMessageReceivedCallback :: C_UserContentManagerScriptMessageReceivedCallback -> IO (FunPtr C_UserContentManagerScriptMessageReceivedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_UserContentManagerScriptMessageReceived :: MonadIO m => UserContentManagerScriptMessageReceivedCallback -> m (GClosure C_UserContentManagerScriptMessageReceivedCallback) +genClosure_UserContentManagerScriptMessageReceived cb = liftIO $ do + let cb' = wrap_UserContentManagerScriptMessageReceivedCallback cb + mk_UserContentManagerScriptMessageReceivedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `UserContentManagerScriptMessageReceivedCallback` into a `C_UserContentManagerScriptMessageReceivedCallback`. +wrap_UserContentManagerScriptMessageReceivedCallback :: + UserContentManagerScriptMessageReceivedCallback -> + C_UserContentManagerScriptMessageReceivedCallback +wrap_UserContentManagerScriptMessageReceivedCallback _cb _ jsResult _ = do + B.ManagedPtr.withTransient WebKit2.JavascriptResult.JavascriptResult jsResult $ \jsResult' -> do + _cb jsResult' + + +{- | +Connect a signal handler for the “@script-message-received@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' userContentManager #scriptMessageReceived callback +@ +-} +onUserContentManagerScriptMessageReceived :: (IsUserContentManager a, MonadIO m) => a -> UserContentManagerScriptMessageReceivedCallback -> m SignalHandlerId +onUserContentManagerScriptMessageReceived obj cb = liftIO $ do + let cb' = wrap_UserContentManagerScriptMessageReceivedCallback cb + cb'' <- mk_UserContentManagerScriptMessageReceivedCallback cb' + connectSignalFunPtr obj "script-message-received" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@script-message-received@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' userContentManager #scriptMessageReceived callback +@ +-} +afterUserContentManagerScriptMessageReceived :: (IsUserContentManager a, MonadIO m) => a -> UserContentManagerScriptMessageReceivedCallback -> m SignalHandlerId +afterUserContentManagerScriptMessageReceived obj cb = liftIO $ do + let cb' = wrap_UserContentManagerScriptMessageReceivedCallback cb + cb'' <- mk_UserContentManagerScriptMessageReceivedCallback cb' + connectSignalFunPtr obj "script-message-received" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserContentManager +type instance O.AttributeList UserContentManager = UserContentManagerAttributeList +type UserContentManagerAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data UserContentManagerScriptMessageReceivedSignalInfo +instance SignalInfo UserContentManagerScriptMessageReceivedSignalInfo where + type HaskellCallbackType UserContentManagerScriptMessageReceivedSignalInfo = UserContentManagerScriptMessageReceivedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_UserContentManagerScriptMessageReceivedCallback cb + cb'' <- mk_UserContentManagerScriptMessageReceivedCallback cb' + connectSignalFunPtr obj "script-message-received" cb'' connectMode + +type instance O.SignalList UserContentManager = UserContentManagerSignalList +type UserContentManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("scriptMessageReceived", UserContentManagerScriptMessageReceivedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method UserContentManager::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_new" webkit_user_content_manager_new :: + IO (Ptr UserContentManager) + +{- | +Creates a new user content manager. + +/Since: 2.6/ +-} +userContentManagerNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m UserContentManager + {- ^ __Returns:__ A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} +userContentManagerNew = liftIO $ do + result <- webkit_user_content_manager_new + checkUnexpectedReturnNULL "userContentManagerNew" result + result' <- (wrapObject UserContentManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserContentManager::add_filter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_add_filter" webkit_user_content_manager_add_filter :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + Ptr WebKit2.UserContentFilter.UserContentFilter -> -- filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}) + IO () + +{- | +Adds a 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' to the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. +The same 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' can be reused with multiple +'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances. + +Filters need to be saved and loaded from 'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore'. + +/Since: 2.24/ +-} +userContentManagerAddFilter :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> WebKit2.UserContentFilter.UserContentFilter + {- ^ /@filter@/: A 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' -} + -> m () +userContentManagerAddFilter manager filter = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + filter' <- unsafeManagedPtrGetPtr filter + webkit_user_content_manager_add_filter manager' filter' + touchManagedPtr manager + touchManagedPtr filter + return () + +#if ENABLE_OVERLOADING +data UserContentManagerAddFilterMethodInfo +instance (signature ~ (WebKit2.UserContentFilter.UserContentFilter -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddFilterMethodInfo a signature where + overloadedMethod _ = userContentManagerAddFilter + +#endif + +-- method UserContentManager::add_script +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "script", argType = TInterface (Name {namespace = "WebKit2", name = "UserScript"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserScript", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_add_script" webkit_user_content_manager_add_script :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + Ptr WebKit2.UserScript.UserScript -> -- script : TInterface (Name {namespace = "WebKit2", name = "UserScript"}) + IO () + +{- | +Adds a 'GI.WebKit2.Structs.UserScript.UserScript' to the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. +The same 'GI.WebKit2.Structs.UserScript.UserScript' can be reused with multiple +'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances. + +/Since: 2.6/ +-} +userContentManagerAddScript :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> WebKit2.UserScript.UserScript + {- ^ /@script@/: A 'GI.WebKit2.Structs.UserScript.UserScript' -} + -> m () +userContentManagerAddScript manager script = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + script' <- unsafeManagedPtrGetPtr script + webkit_user_content_manager_add_script manager' script' + touchManagedPtr manager + touchManagedPtr script + return () + +#if ENABLE_OVERLOADING +data UserContentManagerAddScriptMethodInfo +instance (signature ~ (WebKit2.UserScript.UserScript -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddScriptMethodInfo a signature where + overloadedMethod _ = userContentManagerAddScript + +#endif + +-- method UserContentManager::add_style_sheet +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stylesheet", argType = TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserStyleSheet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_add_style_sheet" webkit_user_content_manager_add_style_sheet :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + Ptr WebKit2.UserStyleSheet.UserStyleSheet -> -- stylesheet : TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}) + IO () + +{- | +Adds a 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' to the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. +The same 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' can be reused with multiple +'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances. + +/Since: 2.6/ +-} +userContentManagerAddStyleSheet :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> WebKit2.UserStyleSheet.UserStyleSheet + {- ^ /@stylesheet@/: A 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} + -> m () +userContentManagerAddStyleSheet manager stylesheet = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + stylesheet' <- unsafeManagedPtrGetPtr stylesheet + webkit_user_content_manager_add_style_sheet manager' stylesheet' + touchManagedPtr manager + touchManagedPtr stylesheet + return () + +#if ENABLE_OVERLOADING +data UserContentManagerAddStyleSheetMethodInfo +instance (signature ~ (WebKit2.UserStyleSheet.UserStyleSheet -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddStyleSheetMethodInfo a signature where + overloadedMethod _ = userContentManagerAddStyleSheet + +#endif + +-- method UserContentManager::register_script_message_handler +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the script message channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_register_script_message_handler" webkit_user_content_manager_register_script_message_handler :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +{- | +Registers a new user script message handler. After it is registered, +scripts can use @window.webkit.messageHandlers.<name>.postMessage(value)@ +to send messages. Those messages are received by connecting handlers +to the 'GI.WebKit2.Objects.UserContentManager.UserContentManager'::@/script-message-received/@ signal. The +handler name is used as the detail of the signal. To avoid race +conditions between registering the handler name, and starting to +receive the signals, it is recommended to connect to the signal +*before* registering the handler name: + +\\ +WebKitWebView *view = webkit_web_view_new (); +WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager (); +g_signal_connect (manager, \"script-message-received::foobar\", + G_CALLBACK (handle_script_message), NULL); +webkit_user_content_manager_register_script_message_handler (manager, \"foobar\"); +\<\/programlisting>\<\/informalexample> + +Registering a script message handler will fail if the requested +name has been already registered before. + +/Since: 2.8/ +-} +userContentManagerRegisterScriptMessageHandler :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> T.Text + {- ^ /@name@/: Name of the script message channel -} + -> m Bool + {- ^ __Returns:__ 'True' if message handler was registered successfully, or 'False' otherwise. -} +userContentManagerRegisterScriptMessageHandler manager name = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + name' <- textToCString name + result <- webkit_user_content_manager_register_script_message_handler manager' name' + let result' = (/= 0) result + touchManagedPtr manager + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data UserContentManagerRegisterScriptMessageHandlerMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRegisterScriptMessageHandlerMethodInfo a signature where + overloadedMethod _ = userContentManagerRegisterScriptMessageHandler + +#endif + +-- method UserContentManager::register_script_message_handler_in_world +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the script message channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "world_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a #WebKitScriptWorld", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_register_script_message_handler_in_world" webkit_user_content_manager_register_script_message_handler_in_world :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- world_name : TBasicType TUTF8 + IO CInt + +{- | +Registers a new user script message handler in script world with name /@worldName@/. +See 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler' for full description. + +Registering a script message handler will fail if the requested +name has been already registered before. + +/Since: 2.22/ +-} +userContentManagerRegisterScriptMessageHandlerInWorld :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> T.Text + {- ^ /@name@/: Name of the script message channel -} + -> T.Text + {- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if message handler was registered successfully, or 'False' otherwise. -} +userContentManagerRegisterScriptMessageHandlerInWorld manager name worldName = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + name' <- textToCString name + worldName' <- textToCString worldName + result <- webkit_user_content_manager_register_script_message_handler_in_world manager' name' worldName' + let result' = (/= 0) result + touchManagedPtr manager + freeMem name' + freeMem worldName' + return result' + +#if ENABLE_OVERLOADING +data UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo +instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo a signature where + overloadedMethod _ = userContentManagerRegisterScriptMessageHandlerInWorld + +#endif + +-- method UserContentManager::remove_all_filters +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_remove_all_filters" webkit_user_content_manager_remove_all_filters :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + IO () + +{- | +Removes all content filters from the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. + +/Since: 2.24/ +-} +userContentManagerRemoveAllFilters :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> m () +userContentManagerRemoveAllFilters manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + webkit_user_content_manager_remove_all_filters manager' + touchManagedPtr manager + return () + +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllFiltersMethodInfo +instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllFiltersMethodInfo a signature where + overloadedMethod _ = userContentManagerRemoveAllFilters + +#endif + +-- method UserContentManager::remove_all_scripts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_remove_all_scripts" webkit_user_content_manager_remove_all_scripts :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + IO () + +{- | +Removes all user scripts from the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager' + +/Since: 2.6/ +-} +userContentManagerRemoveAllScripts :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> m () +userContentManagerRemoveAllScripts manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + webkit_user_content_manager_remove_all_scripts manager' + touchManagedPtr manager + return () + +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllScriptsMethodInfo +instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllScriptsMethodInfo a signature where + overloadedMethod _ = userContentManagerRemoveAllScripts + +#endif + +-- method UserContentManager::remove_all_style_sheets +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_remove_all_style_sheets" webkit_user_content_manager_remove_all_style_sheets :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + IO () + +{- | +Removes all user style sheets from the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. + +/Since: 2.6/ +-} +userContentManagerRemoveAllStyleSheets :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> m () +userContentManagerRemoveAllStyleSheets manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + webkit_user_content_manager_remove_all_style_sheets manager' + touchManagedPtr manager + return () + +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllStyleSheetsMethodInfo +instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllStyleSheetsMethodInfo a signature where + overloadedMethod _ = userContentManagerRemoveAllStyleSheets + +#endif + +-- method UserContentManager::remove_filter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_remove_filter" webkit_user_content_manager_remove_filter :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + Ptr WebKit2.UserContentFilter.UserContentFilter -> -- filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}) + IO () + +{- | +Removes a filter from the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. + +Since 2.24 +-} +userContentManagerRemoveFilter :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> WebKit2.UserContentFilter.UserContentFilter + {- ^ /@filter@/: A 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' -} + -> m () +userContentManagerRemoveFilter manager filter = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + filter' <- unsafeManagedPtrGetPtr filter + webkit_user_content_manager_remove_filter manager' filter' + touchManagedPtr manager + touchManagedPtr filter + return () + +#if ENABLE_OVERLOADING +data UserContentManagerRemoveFilterMethodInfo +instance (signature ~ (WebKit2.UserContentFilter.UserContentFilter -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveFilterMethodInfo a signature where + overloadedMethod _ = userContentManagerRemoveFilter + +#endif + +-- method UserContentManager::unregister_script_message_handler +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the script message channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_unregister_script_message_handler" webkit_user_content_manager_unregister_script_message_handler :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + CString -> -- name : TBasicType TUTF8 + IO () + +{- | +Unregisters a previously registered message handler. + +Note that this does *not* disconnect handlers for the +'GI.WebKit2.Objects.UserContentManager.UserContentManager'::@/script-message-received/@ signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again. + +See also 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler'. + +/Since: 2.8/ +-} +userContentManagerUnregisterScriptMessageHandler :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> T.Text + {- ^ /@name@/: Name of the script message channel -} + -> m () +userContentManagerUnregisterScriptMessageHandler manager name = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + name' <- textToCString name + webkit_user_content_manager_unregister_script_message_handler manager' name' + touchManagedPtr manager + freeMem name' + return () + +#if ENABLE_OVERLOADING +data UserContentManagerUnregisterScriptMessageHandlerMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerUnregisterScriptMessageHandlerMethodInfo a signature where + overloadedMethod _ = userContentManagerUnregisterScriptMessageHandler + +#endif + +-- method UserContentManager::unregister_script_message_handler_in_world +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the script message channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "world_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a #WebKitScriptWorld", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_manager_unregister_script_message_handler_in_world" webkit_user_content_manager_unregister_script_message_handler_in_world :: + Ptr UserContentManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- world_name : TBasicType TUTF8 + IO () + +{- | +Unregisters a previously registered message handler in script world with name /@worldName@/. + +Note that this does *not* disconnect handlers for the +'GI.WebKit2.Objects.UserContentManager.UserContentManager'::@/script-message-received/@ signal; +they will be kept connected, but the signal will not be emitted +unless the handler name is registered again. + +See also 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandlerInWorld'. + +/Since: 2.22/ +-} +userContentManagerUnregisterScriptMessageHandlerInWorld :: + (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) => + a + {- ^ /@manager@/: A 'GI.WebKit2.Objects.UserContentManager.UserContentManager' -} + -> T.Text + {- ^ /@name@/: Name of the script message channel -} + -> T.Text + {- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@ -} + -> m () +userContentManagerUnregisterScriptMessageHandlerInWorld manager name worldName = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + name' <- textToCString name + worldName' <- textToCString worldName + webkit_user_content_manager_unregister_script_message_handler_in_world manager' name' worldName' + touchManagedPtr manager + freeMem name' + freeMem worldName' + return () + +#if ENABLE_OVERLOADING +data UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo a signature where + overloadedMethod _ = userContentManagerUnregisterScriptMessageHandlerInWorld + +#endif + + diff --git a/GI/WebKit2/Objects/UserContentManager.hs-boot b/GI/WebKit2/Objects/UserContentManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserContentManager.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.UserContentManager 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 + +newtype UserContentManager = UserContentManager (ManagedPtr UserContentManager) +instance GObject UserContentManager where +class (GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o +instance (GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o +instance O.HasParentTypes UserContentManager +#if ENABLE_OVERLOADING +data UserContentManagerScriptMessageReceivedSignalInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerAddFilterMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerAddScriptMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerAddStyleSheetMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRegisterScriptMessageHandlerMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllFiltersMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllScriptsMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRemoveAllStyleSheetsMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerRemoveFilterMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerUnregisterScriptMessageHandlerMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo +#endif diff --git a/GI/WebKit2/Objects/UserMediaPermissionRequest.hs b/GI/WebKit2/Objects/UserMediaPermissionRequest.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserMediaPermissionRequest.hs @@ -0,0 +1,219 @@ + + +{- | +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.UserMediaPermissionRequest + ( + +-- * Exported types + UserMediaPermissionRequest(..) , + IsUserMediaPermissionRequest , + toUserMediaPermissionRequest , + noUserMediaPermissionRequest , + + + -- * Properties +-- ** isForAudioDevice #attr:isForAudioDevice# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + UserMediaPermissionRequestIsForAudioDevicePropertyInfo, +#endif + getUserMediaPermissionRequestIsForAudioDevice, +#if ENABLE_OVERLOADING + userMediaPermissionRequestIsForAudioDevice, +#endif + + +-- ** isForVideoDevice #attr:isForVideoDevice# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + UserMediaPermissionRequestIsForVideoDevicePropertyInfo, +#endif + getUserMediaPermissionRequestIsForVideoDevice, +#if ENABLE_OVERLOADING + userMediaPermissionRequestIsForVideoDevice, +#endif + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest + +-- | Memory-managed wrapper type. +newtype UserMediaPermissionRequest = UserMediaPermissionRequest (ManagedPtr UserMediaPermissionRequest) +foreign import ccall "webkit_user_media_permission_request_get_type" + c_webkit_user_media_permission_request_get_type :: IO GType + +instance GObject UserMediaPermissionRequest where + gobjectType = c_webkit_user_media_permission_request_get_type + + +-- | Type class for types which can be safely cast to `UserMediaPermissionRequest`, for instance with `toUserMediaPermissionRequest`. +class (GObject o, O.IsDescendantOf UserMediaPermissionRequest o) => IsUserMediaPermissionRequest o +instance (GObject o, O.IsDescendantOf UserMediaPermissionRequest o) => IsUserMediaPermissionRequest o + +instance O.HasParentTypes UserMediaPermissionRequest +type instance O.ParentTypes UserMediaPermissionRequest = '[GObject.Object.Object, WebKit2.PermissionRequest.PermissionRequest] + +-- | Cast to `UserMediaPermissionRequest`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toUserMediaPermissionRequest :: (MonadIO m, IsUserMediaPermissionRequest o) => o -> m UserMediaPermissionRequest +toUserMediaPermissionRequest = liftIO . unsafeCastTo UserMediaPermissionRequest + +-- | A convenience alias for `Nothing` :: `Maybe` `UserMediaPermissionRequest`. +noUserMediaPermissionRequest :: Maybe UserMediaPermissionRequest +noUserMediaPermissionRequest = Nothing + +#if ENABLE_OVERLOADING +type family ResolveUserMediaPermissionRequestMethod (t :: Symbol) (o :: *) :: * where + ResolveUserMediaPermissionRequestMethod "allow" o = WebKit2.PermissionRequest.PermissionRequestAllowMethodInfo + ResolveUserMediaPermissionRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveUserMediaPermissionRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveUserMediaPermissionRequestMethod "deny" o = WebKit2.PermissionRequest.PermissionRequestDenyMethodInfo + ResolveUserMediaPermissionRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveUserMediaPermissionRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveUserMediaPermissionRequestMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveUserMediaPermissionRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveUserMediaPermissionRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveUserMediaPermissionRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveUserMediaPermissionRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveUserMediaPermissionRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveUserMediaPermissionRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveUserMediaPermissionRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveUserMediaPermissionRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveUserMediaPermissionRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveUserMediaPermissionRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveUserMediaPermissionRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveUserMediaPermissionRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveUserMediaPermissionRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveUserMediaPermissionRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveUserMediaPermissionRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveUserMediaPermissionRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveUserMediaPermissionRequestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserMediaPermissionRequestMethod t UserMediaPermissionRequest, O.MethodInfo info UserMediaPermissionRequest p) => OL.IsLabel t (UserMediaPermissionRequest -> 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 + +-- VVV Prop "is-for-audio-device" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-for-audio-device@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' userMediaPermissionRequest #isForAudioDevice +@ +-} +getUserMediaPermissionRequestIsForAudioDevice :: (MonadIO m, IsUserMediaPermissionRequest o) => o -> m Bool +getUserMediaPermissionRequestIsForAudioDevice obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-for-audio-device" + +#if ENABLE_OVERLOADING +data UserMediaPermissionRequestIsForAudioDevicePropertyInfo +instance AttrInfo UserMediaPermissionRequestIsForAudioDevicePropertyInfo where + type AttrAllowedOps UserMediaPermissionRequestIsForAudioDevicePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint UserMediaPermissionRequestIsForAudioDevicePropertyInfo = (~) () + type AttrBaseTypeConstraint UserMediaPermissionRequestIsForAudioDevicePropertyInfo = IsUserMediaPermissionRequest + type AttrGetType UserMediaPermissionRequestIsForAudioDevicePropertyInfo = Bool + type AttrLabel UserMediaPermissionRequestIsForAudioDevicePropertyInfo = "is-for-audio-device" + type AttrOrigin UserMediaPermissionRequestIsForAudioDevicePropertyInfo = UserMediaPermissionRequest + attrGet _ = getUserMediaPermissionRequestIsForAudioDevice + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "is-for-video-device" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-for-video-device@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' userMediaPermissionRequest #isForVideoDevice +@ +-} +getUserMediaPermissionRequestIsForVideoDevice :: (MonadIO m, IsUserMediaPermissionRequest o) => o -> m Bool +getUserMediaPermissionRequestIsForVideoDevice obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-for-video-device" + +#if ENABLE_OVERLOADING +data UserMediaPermissionRequestIsForVideoDevicePropertyInfo +instance AttrInfo UserMediaPermissionRequestIsForVideoDevicePropertyInfo where + type AttrAllowedOps UserMediaPermissionRequestIsForVideoDevicePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint UserMediaPermissionRequestIsForVideoDevicePropertyInfo = (~) () + type AttrBaseTypeConstraint UserMediaPermissionRequestIsForVideoDevicePropertyInfo = IsUserMediaPermissionRequest + type AttrGetType UserMediaPermissionRequestIsForVideoDevicePropertyInfo = Bool + type AttrLabel UserMediaPermissionRequestIsForVideoDevicePropertyInfo = "is-for-video-device" + type AttrOrigin UserMediaPermissionRequestIsForVideoDevicePropertyInfo = UserMediaPermissionRequest + attrGet _ = getUserMediaPermissionRequestIsForVideoDevice + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserMediaPermissionRequest +type instance O.AttributeList UserMediaPermissionRequest = UserMediaPermissionRequestAttributeList +type UserMediaPermissionRequestAttributeList = ('[ '("isForAudioDevice", UserMediaPermissionRequestIsForAudioDevicePropertyInfo), '("isForVideoDevice", UserMediaPermissionRequestIsForVideoDevicePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +userMediaPermissionRequestIsForAudioDevice :: AttrLabelProxy "isForAudioDevice" +userMediaPermissionRequestIsForAudioDevice = AttrLabelProxy + +userMediaPermissionRequestIsForVideoDevice :: AttrLabelProxy "isForVideoDevice" +userMediaPermissionRequestIsForVideoDevice = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList UserMediaPermissionRequest = UserMediaPermissionRequestSignalList +type UserMediaPermissionRequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/WebKit2/Objects/UserMediaPermissionRequest.hs-boot b/GI/WebKit2/Objects/UserMediaPermissionRequest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/UserMediaPermissionRequest.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.UserMediaPermissionRequest 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 + +newtype UserMediaPermissionRequest = UserMediaPermissionRequest (ManagedPtr UserMediaPermissionRequest) +instance GObject UserMediaPermissionRequest where +class (GObject o, O.IsDescendantOf UserMediaPermissionRequest o) => IsUserMediaPermissionRequest o +instance (GObject o, O.IsDescendantOf UserMediaPermissionRequest o) => IsUserMediaPermissionRequest o +instance O.HasParentTypes UserMediaPermissionRequest +#if ENABLE_OVERLOADING +data UserMediaPermissionRequestIsForAudioDevicePropertyInfo +#endif +#if ENABLE_OVERLOADING +data UserMediaPermissionRequestIsForVideoDevicePropertyInfo +#endif diff --git a/GI/WebKit2/Objects/WebContext.hs b/GI/WebKit2/Objects/WebContext.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebContext.hs @@ -0,0 +1,2648 @@ + + +{- | +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.WebContext + ( + +-- * Exported types + WebContext(..) , + IsWebContext , + toWebContext , + noWebContext , + + + -- * Methods +-- ** allowTlsCertificateForHost #method:allowTlsCertificateForHost# + +#if ENABLE_OVERLOADING + WebContextAllowTlsCertificateForHostMethodInfo, +#endif + webContextAllowTlsCertificateForHost , + + +-- ** clearCache #method:clearCache# + +#if ENABLE_OVERLOADING + WebContextClearCacheMethodInfo , +#endif + webContextClearCache , + + +-- ** downloadUri #method:downloadUri# + +#if ENABLE_OVERLOADING + WebContextDownloadUriMethodInfo , +#endif + webContextDownloadUri , + + +-- ** getCacheModel #method:getCacheModel# + +#if ENABLE_OVERLOADING + WebContextGetCacheModelMethodInfo , +#endif + webContextGetCacheModel , + + +-- ** getCookieManager #method:getCookieManager# + +#if ENABLE_OVERLOADING + WebContextGetCookieManagerMethodInfo , +#endif + webContextGetCookieManager , + + +-- ** getDefault #method:getDefault# + + webContextGetDefault , + + +-- ** getFaviconDatabase #method:getFaviconDatabase# + +#if ENABLE_OVERLOADING + WebContextGetFaviconDatabaseMethodInfo , +#endif + webContextGetFaviconDatabase , + + +-- ** getFaviconDatabaseDirectory #method:getFaviconDatabaseDirectory# + +#if ENABLE_OVERLOADING + WebContextGetFaviconDatabaseDirectoryMethodInfo, +#endif + webContextGetFaviconDatabaseDirectory , + + +-- ** getPlugins #method:getPlugins# + +#if ENABLE_OVERLOADING + WebContextGetPluginsMethodInfo , +#endif + webContextGetPlugins , + + +-- ** getPluginsFinish #method:getPluginsFinish# + +#if ENABLE_OVERLOADING + WebContextGetPluginsFinishMethodInfo , +#endif + webContextGetPluginsFinish , + + +-- ** getProcessModel #method:getProcessModel# + +#if ENABLE_OVERLOADING + WebContextGetProcessModelMethodInfo , +#endif + webContextGetProcessModel , + + +-- ** getSecurityManager #method:getSecurityManager# + +#if ENABLE_OVERLOADING + WebContextGetSecurityManagerMethodInfo , +#endif + webContextGetSecurityManager , + + +-- ** getSpellCheckingEnabled #method:getSpellCheckingEnabled# + +#if ENABLE_OVERLOADING + WebContextGetSpellCheckingEnabledMethodInfo, +#endif + webContextGetSpellCheckingEnabled , + + +-- ** getSpellCheckingLanguages #method:getSpellCheckingLanguages# + +#if ENABLE_OVERLOADING + WebContextGetSpellCheckingLanguagesMethodInfo, +#endif + webContextGetSpellCheckingLanguages , + + +-- ** getTlsErrorsPolicy #method:getTlsErrorsPolicy# + +#if ENABLE_OVERLOADING + WebContextGetTlsErrorsPolicyMethodInfo , +#endif + webContextGetTlsErrorsPolicy , + + +-- ** getWebProcessCountLimit #method:getWebProcessCountLimit# + +#if ENABLE_OVERLOADING + WebContextGetWebProcessCountLimitMethodInfo, +#endif + webContextGetWebProcessCountLimit , + + +-- ** getWebsiteDataManager #method:getWebsiteDataManager# + +#if ENABLE_OVERLOADING + WebContextGetWebsiteDataManagerMethodInfo, +#endif + webContextGetWebsiteDataManager , + + +-- ** initializeNotificationPermissions #method:initializeNotificationPermissions# + +#if ENABLE_OVERLOADING + WebContextInitializeNotificationPermissionsMethodInfo, +#endif + webContextInitializeNotificationPermissions, + + +-- ** isAutomationAllowed #method:isAutomationAllowed# + +#if ENABLE_OVERLOADING + WebContextIsAutomationAllowedMethodInfo , +#endif + webContextIsAutomationAllowed , + + +-- ** isEphemeral #method:isEphemeral# + +#if ENABLE_OVERLOADING + WebContextIsEphemeralMethodInfo , +#endif + webContextIsEphemeral , + + +-- ** new #method:new# + + webContextNew , + + +-- ** newEphemeral #method:newEphemeral# + + webContextNewEphemeral , + + +-- ** newWithWebsiteDataManager #method:newWithWebsiteDataManager# + + webContextNewWithWebsiteDataManager , + + +-- ** prefetchDns #method:prefetchDns# + +#if ENABLE_OVERLOADING + WebContextPrefetchDnsMethodInfo , +#endif + webContextPrefetchDns , + + +-- ** registerUriScheme #method:registerUriScheme# + +#if ENABLE_OVERLOADING + WebContextRegisterUriSchemeMethodInfo , +#endif + webContextRegisterUriScheme , + + +-- ** setAdditionalPluginsDirectory #method:setAdditionalPluginsDirectory# + +#if ENABLE_OVERLOADING + WebContextSetAdditionalPluginsDirectoryMethodInfo, +#endif + webContextSetAdditionalPluginsDirectory , + + +-- ** setAutomationAllowed #method:setAutomationAllowed# + +#if ENABLE_OVERLOADING + WebContextSetAutomationAllowedMethodInfo, +#endif + webContextSetAutomationAllowed , + + +-- ** setCacheModel #method:setCacheModel# + +#if ENABLE_OVERLOADING + WebContextSetCacheModelMethodInfo , +#endif + webContextSetCacheModel , + + +-- ** setDiskCacheDirectory #method:setDiskCacheDirectory# + +#if ENABLE_OVERLOADING + WebContextSetDiskCacheDirectoryMethodInfo, +#endif + webContextSetDiskCacheDirectory , + + +-- ** setFaviconDatabaseDirectory #method:setFaviconDatabaseDirectory# + +#if ENABLE_OVERLOADING + WebContextSetFaviconDatabaseDirectoryMethodInfo, +#endif + webContextSetFaviconDatabaseDirectory , + + +-- ** setNetworkProxySettings #method:setNetworkProxySettings# + +#if ENABLE_OVERLOADING + WebContextSetNetworkProxySettingsMethodInfo, +#endif + webContextSetNetworkProxySettings , + + +-- ** setPreferredLanguages #method:setPreferredLanguages# + +#if ENABLE_OVERLOADING + WebContextSetPreferredLanguagesMethodInfo, +#endif + webContextSetPreferredLanguages , + + +-- ** setProcessModel #method:setProcessModel# + +#if ENABLE_OVERLOADING + WebContextSetProcessModelMethodInfo , +#endif + webContextSetProcessModel , + + +-- ** setSpellCheckingEnabled #method:setSpellCheckingEnabled# + +#if ENABLE_OVERLOADING + WebContextSetSpellCheckingEnabledMethodInfo, +#endif + webContextSetSpellCheckingEnabled , + + +-- ** setSpellCheckingLanguages #method:setSpellCheckingLanguages# + +#if ENABLE_OVERLOADING + WebContextSetSpellCheckingLanguagesMethodInfo, +#endif + webContextSetSpellCheckingLanguages , + + +-- ** setTlsErrorsPolicy #method:setTlsErrorsPolicy# + +#if ENABLE_OVERLOADING + WebContextSetTlsErrorsPolicyMethodInfo , +#endif + webContextSetTlsErrorsPolicy , + + +-- ** setWebExtensionsDirectory #method:setWebExtensionsDirectory# + +#if ENABLE_OVERLOADING + WebContextSetWebExtensionsDirectoryMethodInfo, +#endif + webContextSetWebExtensionsDirectory , + + +-- ** setWebExtensionsInitializationUserData #method:setWebExtensionsInitializationUserData# + +#if ENABLE_OVERLOADING + WebContextSetWebExtensionsInitializationUserDataMethodInfo, +#endif + webContextSetWebExtensionsInitializationUserData, + + +-- ** setWebProcessCountLimit #method:setWebProcessCountLimit# + +#if ENABLE_OVERLOADING + WebContextSetWebProcessCountLimitMethodInfo, +#endif + webContextSetWebProcessCountLimit , + + + + + -- * Properties +-- ** localStorageDirectory #attr:localStorageDirectory# +{- | The directory where local storage data will be saved. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + WebContextLocalStorageDirectoryPropertyInfo, +#endif + constructWebContextLocalStorageDirectory, + getWebContextLocalStorageDirectory , +#if ENABLE_OVERLOADING + webContextLocalStorageDirectory , +#endif + + +-- ** websiteDataManager #attr:websiteDataManager# +{- | The 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' associated with this context. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebContextWebsiteDataManagerPropertyInfo, +#endif + constructWebContextWebsiteDataManager , + getWebContextWebsiteDataManager , +#if ENABLE_OVERLOADING + webContextWebsiteDataManager , +#endif + + + + + -- * Signals +-- ** automationStarted #signal:automationStarted# + + C_WebContextAutomationStartedCallback , + WebContextAutomationStartedCallback , +#if ENABLE_OVERLOADING + WebContextAutomationStartedSignalInfo , +#endif + afterWebContextAutomationStarted , + genClosure_WebContextAutomationStarted , + mk_WebContextAutomationStartedCallback , + noWebContextAutomationStartedCallback , + onWebContextAutomationStarted , + wrap_WebContextAutomationStartedCallback, + + +-- ** downloadStarted #signal:downloadStarted# + + C_WebContextDownloadStartedCallback , + WebContextDownloadStartedCallback , +#if ENABLE_OVERLOADING + WebContextDownloadStartedSignalInfo , +#endif + afterWebContextDownloadStarted , + genClosure_WebContextDownloadStarted , + mk_WebContextDownloadStartedCallback , + noWebContextDownloadStartedCallback , + onWebContextDownloadStarted , + wrap_WebContextDownloadStartedCallback , + + +-- ** initializeNotificationPermissions #signal:initializeNotificationPermissions# + + C_WebContextInitializeNotificationPermissionsCallback, + WebContextInitializeNotificationPermissionsCallback, +#if ENABLE_OVERLOADING + WebContextInitializeNotificationPermissionsSignalInfo, +#endif + afterWebContextInitializeNotificationPermissions, + genClosure_WebContextInitializeNotificationPermissions, + mk_WebContextInitializeNotificationPermissionsCallback, + noWebContextInitializeNotificationPermissionsCallback, + onWebContextInitializeNotificationPermissions, + wrap_WebContextInitializeNotificationPermissionsCallback, + + +-- ** initializeWebExtensions #signal:initializeWebExtensions# + + C_WebContextInitializeWebExtensionsCallback, + WebContextInitializeWebExtensionsCallback, +#if ENABLE_OVERLOADING + WebContextInitializeWebExtensionsSignalInfo, +#endif + afterWebContextInitializeWebExtensions , + genClosure_WebContextInitializeWebExtensions, + mk_WebContextInitializeWebExtensionsCallback, + noWebContextInitializeWebExtensionsCallback, + onWebContextInitializeWebExtensions , + wrap_WebContextInitializeWebExtensionsCallback, + + + + + ) 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.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate +import qualified GI.WebKit2.Callbacks as WebKit2.Callbacks +import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Objects.AutomationSession as WebKit2.AutomationSession +import {-# SOURCE #-} qualified GI.WebKit2.Objects.CookieManager as WebKit2.CookieManager +import {-# SOURCE #-} qualified GI.WebKit2.Objects.Download as WebKit2.Download +import {-# SOURCE #-} qualified GI.WebKit2.Objects.FaviconDatabase as WebKit2.FaviconDatabase +import {-# SOURCE #-} qualified GI.WebKit2.Objects.Plugin as WebKit2.Plugin +import {-# SOURCE #-} qualified GI.WebKit2.Objects.SecurityManager as WebKit2.SecurityManager +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebsiteDataManager as WebKit2.WebsiteDataManager +import {-# SOURCE #-} qualified GI.WebKit2.Structs.NetworkProxySettings as WebKit2.NetworkProxySettings +import {-# SOURCE #-} qualified GI.WebKit2.Structs.SecurityOrigin as WebKit2.SecurityOrigin + +-- | Memory-managed wrapper type. +newtype WebContext = WebContext (ManagedPtr WebContext) +foreign import ccall "webkit_web_context_get_type" + c_webkit_web_context_get_type :: IO GType + +instance GObject WebContext where + gobjectType = c_webkit_web_context_get_type + + +-- | Type class for types which can be safely cast to `WebContext`, for instance with `toWebContext`. +class (GObject o, O.IsDescendantOf WebContext o) => IsWebContext o +instance (GObject o, O.IsDescendantOf WebContext o) => IsWebContext o + +instance O.HasParentTypes WebContext +type instance O.ParentTypes WebContext = '[GObject.Object.Object] + +-- | Cast to `WebContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWebContext :: (MonadIO m, IsWebContext o) => o -> m WebContext +toWebContext = liftIO . unsafeCastTo WebContext + +-- | A convenience alias for `Nothing` :: `Maybe` `WebContext`. +noWebContext :: Maybe WebContext +noWebContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWebContextMethod (t :: Symbol) (o :: *) :: * where + ResolveWebContextMethod "allowTlsCertificateForHost" o = WebContextAllowTlsCertificateForHostMethodInfo + ResolveWebContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWebContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWebContextMethod "clearCache" o = WebContextClearCacheMethodInfo + ResolveWebContextMethod "downloadUri" o = WebContextDownloadUriMethodInfo + ResolveWebContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWebContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWebContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWebContextMethod "initializeNotificationPermissions" o = WebContextInitializeNotificationPermissionsMethodInfo + ResolveWebContextMethod "isAutomationAllowed" o = WebContextIsAutomationAllowedMethodInfo + ResolveWebContextMethod "isEphemeral" o = WebContextIsEphemeralMethodInfo + ResolveWebContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWebContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWebContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWebContextMethod "prefetchDns" o = WebContextPrefetchDnsMethodInfo + ResolveWebContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWebContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWebContextMethod "registerUriScheme" o = WebContextRegisterUriSchemeMethodInfo + ResolveWebContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWebContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWebContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWebContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWebContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWebContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWebContextMethod "getCacheModel" o = WebContextGetCacheModelMethodInfo + ResolveWebContextMethod "getCookieManager" o = WebContextGetCookieManagerMethodInfo + ResolveWebContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWebContextMethod "getFaviconDatabase" o = WebContextGetFaviconDatabaseMethodInfo + ResolveWebContextMethod "getFaviconDatabaseDirectory" o = WebContextGetFaviconDatabaseDirectoryMethodInfo + ResolveWebContextMethod "getPlugins" o = WebContextGetPluginsMethodInfo + ResolveWebContextMethod "getPluginsFinish" o = WebContextGetPluginsFinishMethodInfo + ResolveWebContextMethod "getProcessModel" o = WebContextGetProcessModelMethodInfo + ResolveWebContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWebContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWebContextMethod "getSecurityManager" o = WebContextGetSecurityManagerMethodInfo + ResolveWebContextMethod "getSpellCheckingEnabled" o = WebContextGetSpellCheckingEnabledMethodInfo + ResolveWebContextMethod "getSpellCheckingLanguages" o = WebContextGetSpellCheckingLanguagesMethodInfo + ResolveWebContextMethod "getTlsErrorsPolicy" o = WebContextGetTlsErrorsPolicyMethodInfo + ResolveWebContextMethod "getWebProcessCountLimit" o = WebContextGetWebProcessCountLimitMethodInfo + ResolveWebContextMethod "getWebsiteDataManager" o = WebContextGetWebsiteDataManagerMethodInfo + ResolveWebContextMethod "setAdditionalPluginsDirectory" o = WebContextSetAdditionalPluginsDirectoryMethodInfo + ResolveWebContextMethod "setAutomationAllowed" o = WebContextSetAutomationAllowedMethodInfo + ResolveWebContextMethod "setCacheModel" o = WebContextSetCacheModelMethodInfo + ResolveWebContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWebContextMethod "setDiskCacheDirectory" o = WebContextSetDiskCacheDirectoryMethodInfo + ResolveWebContextMethod "setFaviconDatabaseDirectory" o = WebContextSetFaviconDatabaseDirectoryMethodInfo + ResolveWebContextMethod "setNetworkProxySettings" o = WebContextSetNetworkProxySettingsMethodInfo + ResolveWebContextMethod "setPreferredLanguages" o = WebContextSetPreferredLanguagesMethodInfo + ResolveWebContextMethod "setProcessModel" o = WebContextSetProcessModelMethodInfo + ResolveWebContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWebContextMethod "setSpellCheckingEnabled" o = WebContextSetSpellCheckingEnabledMethodInfo + ResolveWebContextMethod "setSpellCheckingLanguages" o = WebContextSetSpellCheckingLanguagesMethodInfo + ResolveWebContextMethod "setTlsErrorsPolicy" o = WebContextSetTlsErrorsPolicyMethodInfo + ResolveWebContextMethod "setWebExtensionsDirectory" o = WebContextSetWebExtensionsDirectoryMethodInfo + ResolveWebContextMethod "setWebExtensionsInitializationUserData" o = WebContextSetWebExtensionsInitializationUserDataMethodInfo + ResolveWebContextMethod "setWebProcessCountLimit" o = WebContextSetWebProcessCountLimitMethodInfo + ResolveWebContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebContextMethod t WebContext, O.MethodInfo info WebContext p) => OL.IsLabel t (WebContext -> 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 WebContext::automation-started +{- | +This signal is emitted when a new automation request is made. +Note that it will never be emitted if automation is not enabled in /@context@/, +see 'GI.WebKit2.Objects.WebContext.webContextSetAutomationAllowed' for more details. + +/Since: 2.18/ +-} +type WebContextAutomationStartedCallback = + WebKit2.AutomationSession.AutomationSession + {- ^ /@session@/: the 'GI.WebKit2.Objects.AutomationSession.AutomationSession' associated with this event -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextAutomationStartedCallback`@. +noWebContextAutomationStartedCallback :: Maybe WebContextAutomationStartedCallback +noWebContextAutomationStartedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebContextAutomationStartedCallback = + Ptr () -> -- object + Ptr WebKit2.AutomationSession.AutomationSession -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebContextAutomationStartedCallback`. +foreign import ccall "wrapper" + mk_WebContextAutomationStartedCallback :: C_WebContextAutomationStartedCallback -> IO (FunPtr C_WebContextAutomationStartedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebContextAutomationStarted :: MonadIO m => WebContextAutomationStartedCallback -> m (GClosure C_WebContextAutomationStartedCallback) +genClosure_WebContextAutomationStarted cb = liftIO $ do + let cb' = wrap_WebContextAutomationStartedCallback cb + mk_WebContextAutomationStartedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebContextAutomationStartedCallback` into a `C_WebContextAutomationStartedCallback`. +wrap_WebContextAutomationStartedCallback :: + WebContextAutomationStartedCallback -> + C_WebContextAutomationStartedCallback +wrap_WebContextAutomationStartedCallback _cb _ session _ = do + session' <- (newObject WebKit2.AutomationSession.AutomationSession) session + _cb session' + + +{- | +Connect a signal handler for the “@automation-started@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webContext #automationStarted callback +@ +-} +onWebContextAutomationStarted :: (IsWebContext a, MonadIO m) => a -> WebContextAutomationStartedCallback -> m SignalHandlerId +onWebContextAutomationStarted obj cb = liftIO $ do + let cb' = wrap_WebContextAutomationStartedCallback cb + cb'' <- mk_WebContextAutomationStartedCallback cb' + connectSignalFunPtr obj "automation-started" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@automation-started@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webContext #automationStarted callback +@ +-} +afterWebContextAutomationStarted :: (IsWebContext a, MonadIO m) => a -> WebContextAutomationStartedCallback -> m SignalHandlerId +afterWebContextAutomationStarted obj cb = liftIO $ do + let cb' = wrap_WebContextAutomationStartedCallback cb + cb'' <- mk_WebContextAutomationStartedCallback cb' + connectSignalFunPtr obj "automation-started" cb'' SignalConnectAfter + + +-- signal WebContext::download-started +{- | +This signal is emitted when a new download request is made. +-} +type WebContextDownloadStartedCallback = + WebKit2.Download.Download + {- ^ /@download@/: the 'GI.WebKit2.Objects.Download.Download' associated with this event -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextDownloadStartedCallback`@. +noWebContextDownloadStartedCallback :: Maybe WebContextDownloadStartedCallback +noWebContextDownloadStartedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebContextDownloadStartedCallback = + Ptr () -> -- object + Ptr WebKit2.Download.Download -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebContextDownloadStartedCallback`. +foreign import ccall "wrapper" + mk_WebContextDownloadStartedCallback :: C_WebContextDownloadStartedCallback -> IO (FunPtr C_WebContextDownloadStartedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebContextDownloadStarted :: MonadIO m => WebContextDownloadStartedCallback -> m (GClosure C_WebContextDownloadStartedCallback) +genClosure_WebContextDownloadStarted cb = liftIO $ do + let cb' = wrap_WebContextDownloadStartedCallback cb + mk_WebContextDownloadStartedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebContextDownloadStartedCallback` into a `C_WebContextDownloadStartedCallback`. +wrap_WebContextDownloadStartedCallback :: + WebContextDownloadStartedCallback -> + C_WebContextDownloadStartedCallback +wrap_WebContextDownloadStartedCallback _cb _ download _ = do + download' <- (newObject WebKit2.Download.Download) download + _cb download' + + +{- | +Connect a signal handler for the “@download-started@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webContext #downloadStarted callback +@ +-} +onWebContextDownloadStarted :: (IsWebContext a, MonadIO m) => a -> WebContextDownloadStartedCallback -> m SignalHandlerId +onWebContextDownloadStarted obj cb = liftIO $ do + let cb' = wrap_WebContextDownloadStartedCallback cb + cb'' <- mk_WebContextDownloadStartedCallback cb' + connectSignalFunPtr obj "download-started" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@download-started@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webContext #downloadStarted callback +@ +-} +afterWebContextDownloadStarted :: (IsWebContext a, MonadIO m) => a -> WebContextDownloadStartedCallback -> m SignalHandlerId +afterWebContextDownloadStarted obj cb = liftIO $ do + let cb' = wrap_WebContextDownloadStartedCallback cb + cb'' <- mk_WebContextDownloadStartedCallback cb' + connectSignalFunPtr obj "download-started" cb'' SignalConnectAfter + + +-- signal WebContext::initialize-notification-permissions +{- | +This signal is emitted when a 'GI.WebKit2.Objects.WebContext.WebContext' needs to set +initial notification permissions for a web process. It is emitted +when a new web process is about to be launched, and signals the +most appropriate moment to use +'GI.WebKit2.Objects.WebContext.webContextInitializeNotificationPermissions'. If no +notification permissions have changed since the last time this +signal was emitted, then there is no need to call +'GI.WebKit2.Objects.WebContext.webContextInitializeNotificationPermissions' again. + +/Since: 2.16/ +-} +type WebContextInitializeNotificationPermissionsCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextInitializeNotificationPermissionsCallback`@. +noWebContextInitializeNotificationPermissionsCallback :: Maybe WebContextInitializeNotificationPermissionsCallback +noWebContextInitializeNotificationPermissionsCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebContextInitializeNotificationPermissionsCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebContextInitializeNotificationPermissionsCallback`. +foreign import ccall "wrapper" + mk_WebContextInitializeNotificationPermissionsCallback :: C_WebContextInitializeNotificationPermissionsCallback -> IO (FunPtr C_WebContextInitializeNotificationPermissionsCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebContextInitializeNotificationPermissions :: MonadIO m => WebContextInitializeNotificationPermissionsCallback -> m (GClosure C_WebContextInitializeNotificationPermissionsCallback) +genClosure_WebContextInitializeNotificationPermissions cb = liftIO $ do + let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb + mk_WebContextInitializeNotificationPermissionsCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebContextInitializeNotificationPermissionsCallback` into a `C_WebContextInitializeNotificationPermissionsCallback`. +wrap_WebContextInitializeNotificationPermissionsCallback :: + WebContextInitializeNotificationPermissionsCallback -> + C_WebContextInitializeNotificationPermissionsCallback +wrap_WebContextInitializeNotificationPermissionsCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@initialize-notification-permissions@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webContext #initializeNotificationPermissions callback +@ +-} +onWebContextInitializeNotificationPermissions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeNotificationPermissionsCallback -> m SignalHandlerId +onWebContextInitializeNotificationPermissions obj cb = liftIO $ do + let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb + cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb' + connectSignalFunPtr obj "initialize-notification-permissions" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@initialize-notification-permissions@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webContext #initializeNotificationPermissions callback +@ +-} +afterWebContextInitializeNotificationPermissions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeNotificationPermissionsCallback -> m SignalHandlerId +afterWebContextInitializeNotificationPermissions obj cb = liftIO $ do + let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb + cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb' + connectSignalFunPtr obj "initialize-notification-permissions" cb'' SignalConnectAfter + + +-- signal WebContext::initialize-web-extensions +{- | +This signal is emitted when a new web process is about to be +launched. It signals the most appropriate moment to use +'GI.WebKit2.Objects.WebContext.webContextSetWebExtensionsInitializationUserData' +and 'GI.WebKit2.Objects.WebContext.webContextSetWebExtensionsDirectory'. + +/Since: 2.4/ +-} +type WebContextInitializeWebExtensionsCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextInitializeWebExtensionsCallback`@. +noWebContextInitializeWebExtensionsCallback :: Maybe WebContextInitializeWebExtensionsCallback +noWebContextInitializeWebExtensionsCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebContextInitializeWebExtensionsCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebContextInitializeWebExtensionsCallback`. +foreign import ccall "wrapper" + mk_WebContextInitializeWebExtensionsCallback :: C_WebContextInitializeWebExtensionsCallback -> IO (FunPtr C_WebContextInitializeWebExtensionsCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebContextInitializeWebExtensions :: MonadIO m => WebContextInitializeWebExtensionsCallback -> m (GClosure C_WebContextInitializeWebExtensionsCallback) +genClosure_WebContextInitializeWebExtensions cb = liftIO $ do + let cb' = wrap_WebContextInitializeWebExtensionsCallback cb + mk_WebContextInitializeWebExtensionsCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebContextInitializeWebExtensionsCallback` into a `C_WebContextInitializeWebExtensionsCallback`. +wrap_WebContextInitializeWebExtensionsCallback :: + WebContextInitializeWebExtensionsCallback -> + C_WebContextInitializeWebExtensionsCallback +wrap_WebContextInitializeWebExtensionsCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@initialize-web-extensions@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webContext #initializeWebExtensions callback +@ +-} +onWebContextInitializeWebExtensions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeWebExtensionsCallback -> m SignalHandlerId +onWebContextInitializeWebExtensions obj cb = liftIO $ do + let cb' = wrap_WebContextInitializeWebExtensionsCallback cb + cb'' <- mk_WebContextInitializeWebExtensionsCallback cb' + connectSignalFunPtr obj "initialize-web-extensions" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@initialize-web-extensions@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webContext #initializeWebExtensions callback +@ +-} +afterWebContextInitializeWebExtensions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeWebExtensionsCallback -> m SignalHandlerId +afterWebContextInitializeWebExtensions obj cb = liftIO $ do + let cb' = wrap_WebContextInitializeWebExtensionsCallback cb + cb'' <- mk_WebContextInitializeWebExtensionsCallback cb' + connectSignalFunPtr obj "initialize-web-extensions" cb'' SignalConnectAfter + + +-- VVV Prop "local-storage-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@local-storage-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webContext #localStorageDirectory +@ +-} +getWebContextLocalStorageDirectory :: (MonadIO m, IsWebContext o) => o -> m (Maybe T.Text) +getWebContextLocalStorageDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "local-storage-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@local-storage-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebContextLocalStorageDirectory :: (IsWebContext o) => T.Text -> IO (GValueConstruct o) +constructWebContextLocalStorageDirectory val = B.Properties.constructObjectPropertyString "local-storage-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebContextLocalStorageDirectoryPropertyInfo +instance AttrInfo WebContextLocalStorageDirectoryPropertyInfo where + type AttrAllowedOps WebContextLocalStorageDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebContextLocalStorageDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebContextLocalStorageDirectoryPropertyInfo = IsWebContext + type AttrGetType WebContextLocalStorageDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebContextLocalStorageDirectoryPropertyInfo = "local-storage-directory" + type AttrOrigin WebContextLocalStorageDirectoryPropertyInfo = WebContext + attrGet _ = getWebContextLocalStorageDirectory + attrSet _ = undefined + attrConstruct _ = constructWebContextLocalStorageDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "website-data-manager" + -- Type: TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@website-data-manager@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webContext #websiteDataManager +@ +-} +getWebContextWebsiteDataManager :: (MonadIO m, IsWebContext o) => o -> m WebKit2.WebsiteDataManager.WebsiteDataManager +getWebContextWebsiteDataManager obj = liftIO $ checkUnexpectedNothing "getWebContextWebsiteDataManager" $ B.Properties.getObjectPropertyObject obj "website-data-manager" WebKit2.WebsiteDataManager.WebsiteDataManager + +{- | +Construct a `GValueConstruct` with valid value for the “@website-data-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebContextWebsiteDataManager :: (IsWebContext o, WebKit2.WebsiteDataManager.IsWebsiteDataManager a) => a -> IO (GValueConstruct o) +constructWebContextWebsiteDataManager val = B.Properties.constructObjectPropertyObject "website-data-manager" (Just val) + +#if ENABLE_OVERLOADING +data WebContextWebsiteDataManagerPropertyInfo +instance AttrInfo WebContextWebsiteDataManagerPropertyInfo where + type AttrAllowedOps WebContextWebsiteDataManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebContextWebsiteDataManagerPropertyInfo = WebKit2.WebsiteDataManager.IsWebsiteDataManager + type AttrBaseTypeConstraint WebContextWebsiteDataManagerPropertyInfo = IsWebContext + type AttrGetType WebContextWebsiteDataManagerPropertyInfo = WebKit2.WebsiteDataManager.WebsiteDataManager + type AttrLabel WebContextWebsiteDataManagerPropertyInfo = "website-data-manager" + type AttrOrigin WebContextWebsiteDataManagerPropertyInfo = WebContext + attrGet _ = getWebContextWebsiteDataManager + attrSet _ = undefined + attrConstruct _ = constructWebContextWebsiteDataManager + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebContext +type instance O.AttributeList WebContext = WebContextAttributeList +type WebContextAttributeList = ('[ '("localStorageDirectory", WebContextLocalStorageDirectoryPropertyInfo), '("websiteDataManager", WebContextWebsiteDataManagerPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +webContextLocalStorageDirectory :: AttrLabelProxy "localStorageDirectory" +webContextLocalStorageDirectory = AttrLabelProxy + +webContextWebsiteDataManager :: AttrLabelProxy "websiteDataManager" +webContextWebsiteDataManager = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data WebContextAutomationStartedSignalInfo +instance SignalInfo WebContextAutomationStartedSignalInfo where + type HaskellCallbackType WebContextAutomationStartedSignalInfo = WebContextAutomationStartedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebContextAutomationStartedCallback cb + cb'' <- mk_WebContextAutomationStartedCallback cb' + connectSignalFunPtr obj "automation-started" cb'' connectMode + +data WebContextDownloadStartedSignalInfo +instance SignalInfo WebContextDownloadStartedSignalInfo where + type HaskellCallbackType WebContextDownloadStartedSignalInfo = WebContextDownloadStartedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebContextDownloadStartedCallback cb + cb'' <- mk_WebContextDownloadStartedCallback cb' + connectSignalFunPtr obj "download-started" cb'' connectMode + +data WebContextInitializeNotificationPermissionsSignalInfo +instance SignalInfo WebContextInitializeNotificationPermissionsSignalInfo where + type HaskellCallbackType WebContextInitializeNotificationPermissionsSignalInfo = WebContextInitializeNotificationPermissionsCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb + cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb' + connectSignalFunPtr obj "initialize-notification-permissions" cb'' connectMode + +data WebContextInitializeWebExtensionsSignalInfo +instance SignalInfo WebContextInitializeWebExtensionsSignalInfo where + type HaskellCallbackType WebContextInitializeWebExtensionsSignalInfo = WebContextInitializeWebExtensionsCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebContextInitializeWebExtensionsCallback cb + cb'' <- mk_WebContextInitializeWebExtensionsCallback cb' + connectSignalFunPtr obj "initialize-web-extensions" cb'' connectMode + +type instance O.SignalList WebContext = WebContextSignalList +type WebContextSignalList = ('[ '("automationStarted", WebContextAutomationStartedSignalInfo), '("downloadStarted", WebContextDownloadStartedSignalInfo), '("initializeNotificationPermissions", WebContextInitializeNotificationPermissionsSignalInfo), '("initializeWebExtensions", WebContextInitializeWebExtensionsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WebContext::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_new" webkit_web_context_new :: + IO (Ptr WebContext) + +{- | +Create a new 'GI.WebKit2.Objects.WebContext.WebContext' + +/Since: 2.8/ +-} +webContextNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m WebContext + {- ^ __Returns:__ a newly created 'GI.WebKit2.Objects.WebContext.WebContext' -} +webContextNew = liftIO $ do + result <- webkit_web_context_new + checkUnexpectedReturnNULL "webContextNew" result + result' <- (wrapObject WebContext) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebContext::new_ephemeral +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_new_ephemeral" webkit_web_context_new_ephemeral :: + IO (Ptr WebContext) + +{- | +Create a new ephemeral 'GI.WebKit2.Objects.WebContext.WebContext'. An ephemeral 'GI.WebKit2.Objects.WebContext.WebContext' is a context +created with an ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. This is just a convenient method +to create ephemeral contexts without having to create your own 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. +All 'GI.WebKit2.Objects.WebView.WebView'\s associated with this context will also be ephemeral. Websites will +not store any data in the client storage. +This is normally used to implement private instances. + +/Since: 2.16/ +-} +webContextNewEphemeral :: + (B.CallStack.HasCallStack, MonadIO m) => + m WebContext + {- ^ __Returns:__ a new ephemeral 'GI.WebKit2.Objects.WebContext.WebContext'. -} +webContextNewEphemeral = liftIO $ do + result <- webkit_web_context_new_ephemeral + checkUnexpectedReturnNULL "webContextNewEphemeral" result + result' <- (wrapObject WebContext) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebContext::new_with_website_data_manager +-- method type : Constructor +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_new_with_website_data_manager" webkit_web_context_new_with_website_data_manager :: + Ptr WebKit2.WebsiteDataManager.WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO (Ptr WebContext) + +{- | +Create a new 'GI.WebKit2.Objects.WebContext.WebContext' with a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. + +/Since: 2.10/ +-} +webContextNewWithWebsiteDataManager :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.WebsiteDataManager.IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m WebContext + {- ^ __Returns:__ a newly created 'GI.WebKit2.Objects.WebContext.WebContext' -} +webContextNewWithWebsiteDataManager manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_web_context_new_with_website_data_manager manager' + checkUnexpectedReturnNULL "webContextNewWithWebsiteDataManager" result + result' <- (wrapObject WebContext) result + touchManagedPtr manager + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebContext::allow_tls_certificate_for_host +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the host for which a certificate is to be allowed", 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_context_allow_tls_certificate_for_host" webkit_web_context_allow_tls_certificate_for_host :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"}) + CString -> -- host : TBasicType TUTF8 + IO () + +{- | +Ignore further TLS errors on the /@host@/ for the certificate present in /@info@/. + +/Since: 2.6/ +-} +webContextAllowTlsCertificateForHost :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.TlsCertificate.IsTlsCertificate b) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> b + {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -} + -> T.Text + {- ^ /@host@/: the host for which a certificate is to be allowed -} + -> m () +webContextAllowTlsCertificateForHost context certificate host = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + certificate' <- unsafeManagedPtrCastPtr certificate + host' <- textToCString host + webkit_web_context_allow_tls_certificate_for_host context' certificate' host' + touchManagedPtr context + touchManagedPtr certificate + freeMem host' + return () + +#if ENABLE_OVERLOADING +data WebContextAllowTlsCertificateForHostMethodInfo +instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsWebContext a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo WebContextAllowTlsCertificateForHostMethodInfo a signature where + overloadedMethod _ = webContextAllowTlsCertificateForHost + +#endif + +-- method WebContext::clear_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", 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_context_clear_cache" webkit_web_context_clear_cache :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO () + +{- | +Clears all resources currently cached. +See also 'GI.WebKit2.Objects.WebContext.webContextSetCacheModel'. +-} +webContextClearCache :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m () +webContextClearCache context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + webkit_web_context_clear_cache context' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextClearCacheMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextClearCacheMethodInfo a signature where + overloadedMethod _ = webContextClearCache + +#endif + +-- method WebContext::download_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", 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 to download", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Download"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_download_uri" webkit_web_context_download_uri :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- uri : TBasicType TUTF8 + IO (Ptr WebKit2.Download.Download) + +{- | +Requests downloading of the specified URI string. The download operation +will not be associated to any 'GI.WebKit2.Objects.WebView.WebView', if you are interested in +starting a download from a particular 'GI.WebKit2.Objects.WebView.WebView' use +'GI.WebKit2.Objects.WebView.webViewDownloadUri' instead. +-} +webContextDownloadUri :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@uri@/: the URI to download -} + -> m WebKit2.Download.Download + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.Download.Download' representing + the download operation. -} +webContextDownloadUri context uri = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + uri' <- textToCString uri + result <- webkit_web_context_download_uri context' uri' + checkUnexpectedReturnNULL "webContextDownloadUri" result + result' <- (wrapObject WebKit2.Download.Download) result + touchManagedPtr context + freeMem uri' + return result' + +#if ENABLE_OVERLOADING +data WebContextDownloadUriMethodInfo +instance (signature ~ (T.Text -> m WebKit2.Download.Download), MonadIO m, IsWebContext a) => O.MethodInfo WebContextDownloadUriMethodInfo a signature where + overloadedMethod _ = webContextDownloadUri + +#endif + +-- method WebContext::get_cache_model +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CacheModel"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_cache_model" webkit_web_context_get_cache_model :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CUInt + +{- | +Returns the current cache model. For more information about this +value check the documentation of the function +'GI.WebKit2.Objects.WebContext.webContextSetCacheModel'. +-} +webContextGetCacheModel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.Enums.CacheModel + {- ^ __Returns:__ the current 'GI.WebKit2.Enums.CacheModel' -} +webContextGetCacheModel context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_cache_model context' + let result' = (toEnum . fromIntegral) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetCacheModelMethodInfo +instance (signature ~ (m WebKit2.Enums.CacheModel), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetCacheModelMethodInfo a signature where + overloadedMethod _ = webContextGetCacheModel + +#endif + +-- method WebContext::get_cookie_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CookieManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_cookie_manager" webkit_web_context_get_cookie_manager :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr WebKit2.CookieManager.CookieManager) + +{- | +Get the 'GI.WebKit2.Objects.CookieManager.CookieManager' of the /@context@/\'s 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. +-} +webContextGetCookieManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.CookieManager.CookieManager + {- ^ __Returns:__ the 'GI.WebKit2.Objects.CookieManager.CookieManager' of /@context@/. -} +webContextGetCookieManager context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_cookie_manager context' + checkUnexpectedReturnNULL "webContextGetCookieManager" result + result' <- (newObject WebKit2.CookieManager.CookieManager) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetCookieManagerMethodInfo +instance (signature ~ (m WebKit2.CookieManager.CookieManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetCookieManagerMethodInfo a signature where + overloadedMethod _ = webContextGetCookieManager + +#endif + +-- method WebContext::get_favicon_database +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "FaviconDatabase"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_favicon_database" webkit_web_context_get_favicon_database :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr WebKit2.FaviconDatabase.FaviconDatabase) + +{- | +Get the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' associated with /@context@/. + +To initialize the database you need to call +'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory'. +-} +webContextGetFaviconDatabase :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.FaviconDatabase.FaviconDatabase + {- ^ __Returns:__ the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' of /@context@/. -} +webContextGetFaviconDatabase context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_favicon_database context' + checkUnexpectedReturnNULL "webContextGetFaviconDatabase" result + result' <- (newObject WebKit2.FaviconDatabase.FaviconDatabase) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetFaviconDatabaseMethodInfo +instance (signature ~ (m WebKit2.FaviconDatabase.FaviconDatabase), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetFaviconDatabaseMethodInfo a signature where + overloadedMethod _ = webContextGetFaviconDatabase + +#endif + +-- method WebContext::get_favicon_database_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", 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_context_get_favicon_database_directory" webkit_web_context_get_favicon_database_directory :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CString + +{- | +Get the directory path being used to store the favicons database +for /@context@/, or 'Nothing' if +'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory' hasn\'t been +called yet. + +This function will always return the same path after having called +'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory' for the first +time. +-} +webContextGetFaviconDatabaseDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the path of the directory of the favicons +database associated with /@context@/, or 'Nothing'. -} +webContextGetFaviconDatabaseDirectory context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_favicon_database_directory context' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr context + return maybeResult + +#if ENABLE_OVERLOADING +data WebContextGetFaviconDatabaseDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetFaviconDatabaseDirectoryMethodInfo a signature where + overloadedMethod _ = webContextGetFaviconDatabaseDirectory + +#endif + +-- method WebContext::get_plugins +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", 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_context_get_plugins" webkit_web_context_get_plugins :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + 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 list of installed plugins. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebContext.webContextGetPluginsFinish' to get the result of the operation. +-} +webContextGetPlugins :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> 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 () +webContextGetPlugins context cancellable callback = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + 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_context_get_plugins context' maybeCancellable maybeCallback userData + touchManagedPtr context + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebContextGetPluginsMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebContext a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebContextGetPluginsMethodInfo a signature where + overloadedMethod _ = webContextGetPlugins + +#endif + +-- method WebContext::get_plugins_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "Plugin"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_context_get_plugins_finish" webkit_web_context_get_plugins_finish :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (GList (Ptr WebKit2.Plugin.Plugin))) + +{- | +Finish an asynchronous operation started with webkit_web_context_get_plugins. +-} +webContextGetPluginsFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m [WebKit2.Plugin.Plugin] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Objects.Plugin.Plugin'. You must free the 'GI.GLib.Structs.List.List' with + @/g_list_free()/@ and unref the 'GI.WebKit2.Objects.Plugin.Plugin'\s with 'GI.GObject.Objects.Object.objectUnref' when you\'re done with them. /(Can throw 'Data.GI.Base.GError.GError')/ -} +webContextGetPluginsFinish context result_ = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_context_get_plugins_finish context' result_' + result' <- unpackGList result + result'' <- mapM (wrapObject WebKit2.Plugin.Plugin) result' + g_list_free result + touchManagedPtr context + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebContextGetPluginsFinishMethodInfo +instance (signature ~ (b -> m [WebKit2.Plugin.Plugin]), MonadIO m, IsWebContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebContextGetPluginsFinishMethodInfo a signature where + overloadedMethod _ = webContextGetPluginsFinish + +#endif + +-- method WebContext::get_process_model +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ProcessModel"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_process_model" webkit_web_context_get_process_model :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CUInt + +{- | +Returns the current process model. For more information about this value +see 'GI.WebKit2.Objects.WebContext.webContextSetProcessModel'. + +/Since: 2.4/ +-} +webContextGetProcessModel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.Enums.ProcessModel + {- ^ __Returns:__ the current 'GI.WebKit2.Enums.ProcessModel' -} +webContextGetProcessModel context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_process_model context' + let result' = (toEnum . fromIntegral) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetProcessModelMethodInfo +instance (signature ~ (m WebKit2.Enums.ProcessModel), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetProcessModelMethodInfo a signature where + overloadedMethod _ = webContextGetProcessModel + +#endif + +-- method WebContext::get_security_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "SecurityManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_security_manager" webkit_web_context_get_security_manager :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr WebKit2.SecurityManager.SecurityManager) + +{- | +Get the 'GI.WebKit2.Objects.SecurityManager.SecurityManager' of /@context@/. +-} +webContextGetSecurityManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.SecurityManager.SecurityManager + {- ^ __Returns:__ the 'GI.WebKit2.Objects.SecurityManager.SecurityManager' of /@context@/. -} +webContextGetSecurityManager context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_security_manager context' + checkUnexpectedReturnNULL "webContextGetSecurityManager" result + result' <- (newObject WebKit2.SecurityManager.SecurityManager) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetSecurityManagerMethodInfo +instance (signature ~ (m WebKit2.SecurityManager.SecurityManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSecurityManagerMethodInfo a signature where + overloadedMethod _ = webContextGetSecurityManager + +#endif + +-- method WebContext::get_spell_checking_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_spell_checking_enabled" webkit_web_context_get_spell_checking_enabled :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CInt + +{- | +Get whether spell checking feature is currently enabled. +-} +webContextGetSpellCheckingEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m Bool + {- ^ __Returns:__ 'True' If spell checking is enabled, or 'False' otherwise. -} +webContextGetSpellCheckingEnabled context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_spell_checking_enabled context' + let result' = (/= 0) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetSpellCheckingEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSpellCheckingEnabledMethodInfo a signature where + overloadedMethod _ = webContextGetSpellCheckingEnabled + +#endif + +-- method WebContext::get_spell_checking_languages +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_spell_checking_languages" webkit_web_context_get_spell_checking_languages :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr CString) + +{- | +Get the the list of spell checking languages associated with +/@context@/, or 'Nothing' if no languages have been previously set. + +See 'GI.WebKit2.Objects.WebContext.webContextSetSpellCheckingLanguages' for more +details on the format of the languages in the list. +-} +webContextGetSpellCheckingLanguages :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ A 'Nothing'-terminated + array of languages if available, or 'Nothing' otherwise. -} +webContextGetSpellCheckingLanguages context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_spell_checking_languages context' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr context + return maybeResult + +#if ENABLE_OVERLOADING +data WebContextGetSpellCheckingLanguagesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSpellCheckingLanguagesMethodInfo a signature where + overloadedMethod _ = webContextGetSpellCheckingLanguages + +#endif + +-- method WebContext::get_tls_errors_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "TLSErrorsPolicy"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_tls_errors_policy" webkit_web_context_get_tls_errors_policy :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CUInt + +{- | +Get the TLS errors policy of /@context@/ +-} +webContextGetTlsErrorsPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.Enums.TLSErrorsPolicy + {- ^ __Returns:__ a 'GI.WebKit2.Enums.TLSErrorsPolicy' -} +webContextGetTlsErrorsPolicy context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_tls_errors_policy context' + let result' = (toEnum . fromIntegral) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetTlsErrorsPolicyMethodInfo +instance (signature ~ (m WebKit2.Enums.TLSErrorsPolicy), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetTlsErrorsPolicyMethodInfo a signature where + overloadedMethod _ = webContextGetTlsErrorsPolicy + +#endif + +-- method WebContext::get_web_process_count_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_web_process_count_limit" webkit_web_context_get_web_process_count_limit :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO Word32 + +{- | +Gets the maximum number of web processes that can be created at the same time for the /@context@/. + +/Since: 2.10/ +-} +webContextGetWebProcessCountLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m Word32 + {- ^ __Returns:__ the maximum limit of web processes, or 0 if there isn\'t a limit. -} +webContextGetWebProcessCountLimit context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_web_process_count_limit context' + touchManagedPtr context + return result + +#if ENABLE_OVERLOADING +data WebContextGetWebProcessCountLimitMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetWebProcessCountLimitMethodInfo a signature where + overloadedMethod _ = webContextGetWebProcessCountLimit + +#endif + +-- method WebContext::get_website_data_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_website_data_manager" webkit_web_context_get_website_data_manager :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr WebKit2.WebsiteDataManager.WebsiteDataManager) + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' of /@context@/. + +/Since: 2.10/ +-} +webContextGetWebsiteDataManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m WebKit2.WebsiteDataManager.WebsiteDataManager + {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} +webContextGetWebsiteDataManager context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_get_website_data_manager context' + checkUnexpectedReturnNULL "webContextGetWebsiteDataManager" result + result' <- (newObject WebKit2.WebsiteDataManager.WebsiteDataManager) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextGetWebsiteDataManagerMethodInfo +instance (signature ~ (m WebKit2.WebsiteDataManager.WebsiteDataManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetWebsiteDataManagerMethodInfo a signature where + overloadedMethod _ = webContextGetWebsiteDataManager + +#endif + +-- method WebContext::initialize_notification_permissions +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed_origins", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of security origins", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disallowed_origins", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of security origins", 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_context_initialize_notification_permissions" webkit_web_context_initialize_notification_permissions :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr (GList (Ptr WebKit2.SecurityOrigin.SecurityOrigin)) -> -- allowed_origins : TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})) + Ptr (GList (Ptr WebKit2.SecurityOrigin.SecurityOrigin)) -> -- disallowed_origins : TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})) + IO () + +{- | +Sets initial desktop notification permissions for the /@context@/. +/@allowedOrigins@/ and /@disallowedOrigins@/ must each be 'GI.GLib.Structs.List.List' of +'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' objects representing origins that will, +respectively, either always or never have permission to show desktop +notifications. No 'GI.WebKit2.Objects.NotificationPermissionRequest.NotificationPermissionRequest' will ever be +generated for any of the security origins represented in +/@allowedOrigins@/ or /@disallowedOrigins@/. This function is necessary +because some webpages proactively check whether they have permission +to display notifications without ever creating a permission request. + +This function only affects web processes that have not already been +created. The best time to call it is when handling +'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-notification-permissions/@ so as to +ensure that new web processes receive the most recent set of +permissions. + +/Since: 2.16/ +-} +webContextInitializeNotificationPermissions :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> [WebKit2.SecurityOrigin.SecurityOrigin] + {- ^ /@allowedOrigins@/: a 'GI.GLib.Structs.List.List' of security origins -} + -> [WebKit2.SecurityOrigin.SecurityOrigin] + {- ^ /@disallowedOrigins@/: a 'GI.GLib.Structs.List.List' of security origins -} + -> m () +webContextInitializeNotificationPermissions context allowedOrigins disallowedOrigins = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + allowedOrigins' <- mapM unsafeManagedPtrGetPtr allowedOrigins + allowedOrigins'' <- packGList allowedOrigins' + disallowedOrigins' <- mapM unsafeManagedPtrGetPtr disallowedOrigins + disallowedOrigins'' <- packGList disallowedOrigins' + webkit_web_context_initialize_notification_permissions context' allowedOrigins'' disallowedOrigins'' + touchManagedPtr context + mapM_ touchManagedPtr allowedOrigins + mapM_ touchManagedPtr disallowedOrigins + g_list_free allowedOrigins'' + g_list_free disallowedOrigins'' + return () + +#if ENABLE_OVERLOADING +data WebContextInitializeNotificationPermissionsMethodInfo +instance (signature ~ ([WebKit2.SecurityOrigin.SecurityOrigin] -> [WebKit2.SecurityOrigin.SecurityOrigin] -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextInitializeNotificationPermissionsMethodInfo a signature where + overloadedMethod _ = webContextInitializeNotificationPermissions + +#endif + +-- method WebContext::is_automation_allowed +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_is_automation_allowed" webkit_web_context_is_automation_allowed :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CInt + +{- | +Get whether automation is allowed in /@context@/. +See also 'GI.WebKit2.Objects.WebContext.webContextSetAutomationAllowed'. + +/Since: 2.18/ +-} +webContextIsAutomationAllowed :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m Bool + {- ^ __Returns:__ 'True' if automation is allowed or 'False' otherwise. -} +webContextIsAutomationAllowed context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_is_automation_allowed context' + let result' = (/= 0) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextIsAutomationAllowedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextIsAutomationAllowedMethodInfo a signature where + overloadedMethod _ = webContextIsAutomationAllowed + +#endif + +-- method WebContext::is_ephemeral +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_is_ephemeral" webkit_web_context_is_ephemeral :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO CInt + +{- | +Get whether a 'GI.WebKit2.Objects.WebContext.WebContext' is ephemeral. + +/Since: 2.16/ +-} +webContextIsEphemeral :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@context@/ is ephemeral or 'False' otherwise. -} +webContextIsEphemeral context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_context_is_ephemeral context' + let result' = (/= 0) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data WebContextIsEphemeralMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextIsEphemeralMethodInfo a signature where + overloadedMethod _ = webContextIsEphemeral + +#endif + +-- method WebContext::prefetch_dns +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a hostname to be resolved", 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_context_prefetch_dns" webkit_web_context_prefetch_dns :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- hostname : TBasicType TUTF8 + IO () + +{- | +Resolve the domain name of the given /@hostname@/ in advance, so that if a URI +of /@hostname@/ is requested the load will be performed more quickly. +-} +webContextPrefetchDns :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@hostname@/: a hostname to be resolved -} + -> m () +webContextPrefetchDns context hostname = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + hostname' <- textToCString hostname + webkit_web_context_prefetch_dns context' hostname' + touchManagedPtr context + freeMem hostname' + return () + +#if ENABLE_OVERLOADING +data WebContextPrefetchDnsMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextPrefetchDnsMethodInfo a signature where + overloadedMethod _ = webContextPrefetchDns + +#endif + +-- method WebContext::register_uri_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the network scheme to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequestCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequestCallback", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_destroy_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destroy notify for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_register_uri_scheme" webkit_web_context_register_uri_scheme :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- scheme : TBasicType TUTF8 + FunPtr WebKit2.Callbacks.C_URISchemeRequestCallback -> -- callback : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequestCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_destroy_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Register /@scheme@/ in /@context@/, so that when an URI request with /@scheme@/ is made in the +'GI.WebKit2.Objects.WebContext.WebContext', the 'GI.WebKit2.Callbacks.URISchemeRequestCallback' registered will be called with a +'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest'. +It is possible to handle URI scheme requests asynchronously, by calling 'GI.GObject.Objects.Object.objectRef' on the +'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' and calling 'GI.WebKit2.Objects.URISchemeRequest.uRISchemeRequestFinish' later +when the data of the request is available or +'GI.WebKit2.Objects.URISchemeRequest.uRISchemeRequestFinishError' in case of error. + +\\ +static void +about_uri_scheme_request_cb (WebKitURISchemeRequest *request, + gpointer user_data) +{ + GInputStream *stream; + gsize stream_length; + const gchar *path; + + path = webkit_uri_scheme_request_get_path (request); + if (!g_strcmp0 (path, \"plugins\")) { + \/\* Create a GInputStream with the contents of plugins about page, and set its length to stream_length *\\/ + } else if (!g_strcmp0 (path, \"memory\")) { + \/\* Create a GInputStream with the contents of memory about page, and set its length to stream_length *\\/ + } else if (!g_strcmp0 (path, \"applications\")) { + \/\* Create a GInputStream with the contents of applications about page, and set its length to stream_length *\\/ + } else if (!g_strcmp0 (path, \"example\")) { + gchar *contents; + + contents = g_strdup_printf (\"<html><body><p>Example about page<\/p><\/body><\/html>\"); + stream_length = strlen (contents); + stream = g_memory_input_stream_new_from_data (contents, stream_length, g_free); + } else { + GError *error; + + error = g_error_new (ABOUT_HANDLER_ERROR, ABOUT_HANDLER_ERROR_INVALID, \"Invalid about:@/s/@ page.\", path); + webkit_uri_scheme_request_finish_error (request, error); + g_error_free (error); + return; + } + webkit_uri_scheme_request_finish (request, stream, stream_length, \"text\/html\"); + g_object_unref (stream); +} +\<\/programlisting>\<\/informalexample> +-} +webContextRegisterUriScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@scheme@/: the network scheme to register -} + -> WebKit2.Callbacks.URISchemeRequestCallback + {- ^ /@callback@/: a 'GI.WebKit2.Callbacks.URISchemeRequestCallback' -} + -> m () +webContextRegisterUriScheme context scheme callback = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + scheme' <- textToCString scheme + callback' <- WebKit2.Callbacks.mk_URISchemeRequestCallback (WebKit2.Callbacks.wrap_URISchemeRequestCallback Nothing (WebKit2.Callbacks.drop_closures_URISchemeRequestCallback callback)) + let userData = castFunPtrToPtr callback' + let userDataDestroyFunc = safeFreeFunPtrPtr + webkit_web_context_register_uri_scheme context' scheme' callback' userData userDataDestroyFunc + touchManagedPtr context + freeMem scheme' + return () + +#if ENABLE_OVERLOADING +data WebContextRegisterUriSchemeMethodInfo +instance (signature ~ (T.Text -> WebKit2.Callbacks.URISchemeRequestCallback -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextRegisterUriSchemeMethodInfo a signature where + overloadedMethod _ = webContextRegisterUriScheme + +#endif + +-- method WebContext::set_additional_plugins_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the directory to add", 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_context_set_additional_plugins_directory" webkit_web_context_set_additional_plugins_directory :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- directory : TBasicType TUTF8 + IO () + +{- | +Set an additional directory where WebKit will look for plugins. +-} +webContextSetAdditionalPluginsDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@directory@/: the directory to add -} + -> m () +webContextSetAdditionalPluginsDirectory context directory = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + directory' <- textToCString directory + webkit_web_context_set_additional_plugins_directory context' directory' + touchManagedPtr context + freeMem directory' + return () + +#if ENABLE_OVERLOADING +data WebContextSetAdditionalPluginsDirectoryMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetAdditionalPluginsDirectoryMethodInfo a signature where + overloadedMethod _ = webContextSetAdditionalPluginsDirectory + +#endif + +-- method WebContext::set_automation_allowed +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value to set", 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_context_set_automation_allowed" webkit_web_context_set_automation_allowed :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CInt -> -- allowed : TBasicType TBoolean + IO () + +{- | +Set whether automation is allowed in /@context@/. When automation is enabled the browser could +be controlled by another process by requesting an automation session. When a new automation +session is requested the signal 'GI.WebKit2.Objects.WebContext.WebContext'::@/automation-started/@ is emitted. +Automation is disabled by default, so you need to explicitly call this method passing 'True' +to enable it. + +Note that only one 'GI.WebKit2.Objects.WebContext.WebContext' can have automation enabled, so this will do nothing +if there\'s another 'GI.WebKit2.Objects.WebContext.WebContext' with automation already enabled. + +/Since: 2.18/ +-} +webContextSetAutomationAllowed :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> Bool + {- ^ /@allowed@/: value to set -} + -> m () +webContextSetAutomationAllowed context allowed = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let allowed' = (fromIntegral . fromEnum) allowed + webkit_web_context_set_automation_allowed context' allowed' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetAutomationAllowedMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetAutomationAllowedMethodInfo a signature where + overloadedMethod _ = webContextSetAutomationAllowed + +#endif + +-- method WebContext::set_cache_model +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache_model", argType = TInterface (Name {namespace = "WebKit2", name = "CacheModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCacheModel", 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_context_set_cache_model" webkit_web_context_set_cache_model :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CUInt -> -- cache_model : TInterface (Name {namespace = "WebKit2", name = "CacheModel"}) + IO () + +{- | +Specifies a usage model for WebViews, which WebKit will use to +determine its caching behavior. All web views follow the cache +model. This cache model determines the RAM and disk space to use +for caching previously viewed content . + +Research indicates that users tend to browse within clusters of +documents that hold resources in common, and to revisit previously +visited documents. WebKit and the frameworks below it include +built-in caches that take advantage of these patterns, +substantially improving document load speed in browsing +situations. The WebKit cache model controls the behaviors of all of +these caches, including various WebCore caches. + +Browsers can improve document load speed substantially by +specifying 'GI.WebKit2.Enums.CacheModelWebBrowser'. Applications without a +browsing interface can reduce memory usage substantially by +specifying 'GI.WebKit2.Enums.CacheModelDocumentViewer'. The default value is +'GI.WebKit2.Enums.CacheModelWebBrowser'. +-} +webContextSetCacheModel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> WebKit2.Enums.CacheModel + {- ^ /@cacheModel@/: a 'GI.WebKit2.Enums.CacheModel' -} + -> m () +webContextSetCacheModel context cacheModel = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let cacheModel' = (fromIntegral . fromEnum) cacheModel + webkit_web_context_set_cache_model context' cacheModel' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetCacheModelMethodInfo +instance (signature ~ (WebKit2.Enums.CacheModel -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetCacheModelMethodInfo a signature where + overloadedMethod _ = webContextSetCacheModel + +#endif + +-- method WebContext::set_disk_cache_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the directory to set", 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_context_set_disk_cache_directory" webkit_web_context_set_disk_cache_directory :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- directory : TBasicType TUTF8 + IO () + +{-# DEPRECATED webContextSetDiskCacheDirectory ["(Since version 2.10.)","Use 'GI.WebKit2.Objects.WebContext.webContextNewWithWebsiteDataManager' instead."] #-} +{- | +Set the directory where disk cache files will be stored +This method must be called before loading anything in this context, otherwise +it will not have any effect. + +Note that this method overrides the directory set in the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager', +but it doesn\'t change the value returned by 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetDiskCacheDirectory' +since the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is immutable. +-} +webContextSetDiskCacheDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@directory@/: the directory to set -} + -> m () +webContextSetDiskCacheDirectory context directory = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + directory' <- textToCString directory + webkit_web_context_set_disk_cache_directory context' directory' + touchManagedPtr context + freeMem directory' + return () + +#if ENABLE_OVERLOADING +data WebContextSetDiskCacheDirectoryMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetDiskCacheDirectoryMethodInfo a signature where + overloadedMethod _ = webContextSetDiskCacheDirectory + +#endif + +-- method WebContext::set_favicon_database_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an absolute path to the icon database\ndirectory or %NULL to use the defaults", 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_context_set_favicon_database_directory" webkit_web_context_set_favicon_database_directory :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- path : TBasicType TUTF8 + IO () + +{- | +Set the directory path to be used to store the favicons database +for /@context@/ on disk. Passing 'Nothing' as /@path@/ means using the +default directory for the platform (see 'GI.GLib.Functions.getUserCacheDir'). + +Calling this method also means enabling the favicons database for +its use from the applications, so that\'s why it\'s expected to be +called only once. Further calls for the same instance of +'GI.WebKit2.Objects.WebContext.WebContext' won\'t cause any effect. +-} +webContextSetFaviconDatabaseDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> Maybe (T.Text) + {- ^ /@path@/: an absolute path to the icon database +directory or 'Nothing' to use the defaults -} + -> m () +webContextSetFaviconDatabaseDirectory context path = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybePath <- case path of + Nothing -> return nullPtr + Just jPath -> do + jPath' <- textToCString jPath + return jPath' + webkit_web_context_set_favicon_database_directory context' maybePath + touchManagedPtr context + freeMem maybePath + return () + +#if ENABLE_OVERLOADING +data WebContextSetFaviconDatabaseDirectoryMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetFaviconDatabaseDirectoryMethodInfo a signature where + overloadedMethod _ = webContextSetFaviconDatabaseDirectory + +#endif + +-- method WebContext::set_network_proxy_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_mode", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxyMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxyMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_settings", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxySettings, or %NULL", 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_context_set_network_proxy_settings" webkit_web_context_set_network_proxy_settings :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CUInt -> -- proxy_mode : TInterface (Name {namespace = "WebKit2", name = "NetworkProxyMode"}) + Ptr WebKit2.NetworkProxySettings.NetworkProxySettings -> -- proxy_settings : TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}) + IO () + +{- | +Set the network proxy settings to be used by connections started in /@context@/. +By default 'GI.WebKit2.Enums.NetworkProxyModeDefault' is used, which means that the +system settings will be used ('GI.Gio.Functions.proxyResolverGetDefault'). +If you want to override the system default settings, you can either use +'GI.WebKit2.Enums.NetworkProxyModeNoProxy' to make sure no proxies are used at all, +or 'GI.WebKit2.Enums.NetworkProxyModeCustom' to provide your own proxy settings. +When /@proxyMode@/ is 'GI.WebKit2.Enums.NetworkProxyModeCustom' /@proxySettings@/ must be +a valid 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings'; otherwise, /@proxySettings@/ must be 'Nothing'. + +/Since: 2.16/ +-} +webContextSetNetworkProxySettings :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> WebKit2.Enums.NetworkProxyMode + {- ^ /@proxyMode@/: a 'GI.WebKit2.Enums.NetworkProxyMode' -} + -> Maybe (WebKit2.NetworkProxySettings.NetworkProxySettings) + {- ^ /@proxySettings@/: a 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings', or 'Nothing' -} + -> m () +webContextSetNetworkProxySettings context proxyMode proxySettings = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let proxyMode' = (fromIntegral . fromEnum) proxyMode + maybeProxySettings <- case proxySettings of + Nothing -> return nullPtr + Just jProxySettings -> do + jProxySettings' <- unsafeManagedPtrGetPtr jProxySettings + return jProxySettings' + webkit_web_context_set_network_proxy_settings context' proxyMode' maybeProxySettings + touchManagedPtr context + whenJust proxySettings touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebContextSetNetworkProxySettingsMethodInfo +instance (signature ~ (WebKit2.Enums.NetworkProxyMode -> Maybe (WebKit2.NetworkProxySettings.NetworkProxySettings) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetNetworkProxySettingsMethodInfo a signature where + overloadedMethod _ = webContextSetNetworkProxySettings + +#endif + +-- method WebContext::set_preferred_languages +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "languages", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL-terminated list of language identifiers", 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_context_set_preferred_languages" webkit_web_context_set_preferred_languages :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr CString -> -- languages : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Set the list of preferred languages, sorted from most desirable +to least desirable. The list will be used to build the \"Accept-Language\" +header that will be included in the network requests started by +the 'GI.WebKit2.Objects.WebContext.WebContext'. +-} +webContextSetPreferredLanguages :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> Maybe ([T.Text]) + {- ^ /@languages@/: a 'Nothing'-terminated list of language identifiers -} + -> m () +webContextSetPreferredLanguages context languages = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + maybeLanguages <- case languages of + Nothing -> return nullPtr + Just jLanguages -> do + jLanguages' <- packZeroTerminatedUTF8CArray jLanguages + return jLanguages' + webkit_web_context_set_preferred_languages context' maybeLanguages + touchManagedPtr context + mapZeroTerminatedCArray freeMem maybeLanguages + freeMem maybeLanguages + return () + +#if ENABLE_OVERLOADING +data WebContextSetPreferredLanguagesMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetPreferredLanguagesMethodInfo a signature where + overloadedMethod _ = webContextSetPreferredLanguages + +#endif + +-- method WebContext::set_process_model +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "process_model", argType = TInterface (Name {namespace = "WebKit2", name = "ProcessModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitProcessModel", 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_context_set_process_model" webkit_web_context_set_process_model :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CUInt -> -- process_model : TInterface (Name {namespace = "WebKit2", name = "ProcessModel"}) + IO () + +{- | +Specifies a process model for WebViews, which WebKit will use to +determine how auxiliary processes are handled. The default setting +('GI.WebKit2.Enums.ProcessModelSharedSecondaryProcess') is suitable for most +applications which embed a small amount of WebViews, or are used to +display documents which are considered safe — like local files. + +Applications which may potentially use a large amount of WebViews +—for example a multi-tabbed web browser— may want to use +'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses', which will use +one process per view most of the time, while still allowing for web +views to share a process when needed (for example when different +views interact with each other). Using this model, when a process +hangs or crashes, only the WebViews using it stop working, while +the rest of the WebViews in the application will still function +normally. + +This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash. + +/Since: 2.4/ +-} +webContextSetProcessModel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> WebKit2.Enums.ProcessModel + {- ^ /@processModel@/: a 'GI.WebKit2.Enums.ProcessModel' -} + -> m () +webContextSetProcessModel context processModel = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let processModel' = (fromIntegral . fromEnum) processModel + webkit_web_context_set_process_model context' processModel' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetProcessModelMethodInfo +instance (signature ~ (WebKit2.Enums.ProcessModel -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetProcessModelMethodInfo a signature where + overloadedMethod _ = webContextSetProcessModel + +#endif + +-- method WebContext::set_spell_checking_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", 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_context_set_spell_checking_enabled" webkit_web_context_set_spell_checking_enabled :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Enable or disable the spell checking feature. +-} +webContextSetSpellCheckingEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> Bool + {- ^ /@enabled@/: Value to be set -} + -> m () +webContextSetSpellCheckingEnabled context enabled = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let enabled' = (fromIntegral . fromEnum) enabled + webkit_web_context_set_spell_checking_enabled context' enabled' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetSpellCheckingEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetSpellCheckingEnabledMethodInfo a signature where + overloadedMethod _ = webContextSetSpellCheckingEnabled + +#endif + +-- method WebContext::set_spell_checking_languages +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "languages", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a %NULL-terminated list of spell checking languages", 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_context_set_spell_checking_languages" webkit_web_context_set_spell_checking_languages :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr CString -> -- languages : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Set the list of spell checking languages to be used for spell +checking. + +The locale string typically is in the form lang_COUNTRY, where lang +is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. +For instance, sv_FI for Swedish as written in Finland or pt_BR +for Portuguese as written in Brazil. + +You need to call this function with a valid list of languages at +least once in order to properly enable the spell checking feature +in WebKit. +-} +webContextSetSpellCheckingLanguages :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> [T.Text] + {- ^ /@languages@/: a 'Nothing'-terminated list of spell checking languages -} + -> m () +webContextSetSpellCheckingLanguages context languages = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + languages' <- packZeroTerminatedUTF8CArray languages + webkit_web_context_set_spell_checking_languages context' languages' + touchManagedPtr context + mapZeroTerminatedCArray freeMem languages' + freeMem languages' + return () + +#if ENABLE_OVERLOADING +data WebContextSetSpellCheckingLanguagesMethodInfo +instance (signature ~ ([T.Text] -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetSpellCheckingLanguagesMethodInfo a signature where + overloadedMethod _ = webContextSetSpellCheckingLanguages + +#endif + +-- method WebContext::set_tls_errors_policy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "policy", argType = TInterface (Name {namespace = "WebKit2", name = "TLSErrorsPolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitTLSErrorsPolicy", 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_context_set_tls_errors_policy" webkit_web_context_set_tls_errors_policy :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CUInt -> -- policy : TInterface (Name {namespace = "WebKit2", name = "TLSErrorsPolicy"}) + IO () + +{- | +Set the TLS errors policy of /@context@/ as /@policy@/ +-} +webContextSetTlsErrorsPolicy :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> WebKit2.Enums.TLSErrorsPolicy + {- ^ /@policy@/: a 'GI.WebKit2.Enums.TLSErrorsPolicy' -} + -> m () +webContextSetTlsErrorsPolicy context policy = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + let policy' = (fromIntegral . fromEnum) policy + webkit_web_context_set_tls_errors_policy context' policy' + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetTlsErrorsPolicyMethodInfo +instance (signature ~ (WebKit2.Enums.TLSErrorsPolicy -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetTlsErrorsPolicyMethodInfo a signature where + overloadedMethod _ = webContextSetTlsErrorsPolicy + +#endif + +-- method WebContext::set_web_extensions_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the directory to add", 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_context_set_web_extensions_directory" webkit_web_context_set_web_extensions_directory :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + CString -> -- directory : TBasicType TUTF8 + IO () + +{- | +Set the directory where WebKit will look for Web Extensions. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-web-extensions/@ to call this method +before anything is loaded. +-} +webContextSetWebExtensionsDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> T.Text + {- ^ /@directory@/: the directory to add -} + -> m () +webContextSetWebExtensionsDirectory context directory = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + directory' <- textToCString directory + webkit_web_context_set_web_extensions_directory context' directory' + touchManagedPtr context + freeMem directory' + return () + +#if ENABLE_OVERLOADING +data WebContextSetWebExtensionsDirectoryMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebExtensionsDirectoryMethodInfo a signature where + overloadedMethod _ = webContextSetWebExtensionsDirectory + +#endif + +-- method WebContext::set_web_extensions_initialization_user_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVariant", 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_context_set_web_extensions_initialization_user_data" webkit_web_context_set_web_extensions_initialization_user_data :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Ptr GVariant -> -- user_data : TVariant + IO () + +{- | +Set user data to be passed to Web Extensions on initialization. +The data will be passed to the +@/WebKitWebExtensionInitializeWithUserDataFunction/@. +This method must be called before loading anything in this context, +otherwise it will not have any effect. You can connect to +'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-web-extensions/@ to call this method +before anything is loaded. + +/Since: 2.4/ +-} +webContextSetWebExtensionsInitializationUserData :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> GVariant + {- ^ /@userData@/: a 'GVariant' -} + -> m () +webContextSetWebExtensionsInitializationUserData context userData = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + userData' <- unsafeManagedPtrGetPtr userData + webkit_web_context_set_web_extensions_initialization_user_data context' userData' + touchManagedPtr context + touchManagedPtr userData + return () + +#if ENABLE_OVERLOADING +data WebContextSetWebExtensionsInitializationUserDataMethodInfo +instance (signature ~ (GVariant -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebExtensionsInitializationUserDataMethodInfo a signature where + overloadedMethod _ = webContextSetWebExtensionsInitializationUserData + +#endif + +-- method WebContext::set_web_process_count_limit +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum number of web processes", 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_context_set_web_process_count_limit" webkit_web_context_set_web_process_count_limit :: + Ptr WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + Word32 -> -- limit : TBasicType TUInt + IO () + +{- | +Sets the maximum number of web processes that can be created at the same time for the /@context@/. +The default value is 0 and means no limit. + +This method **must be called before any web process has been created**, +as early as possible in your application. Calling it later will make +your application crash. + +/Since: 2.10/ +-} +webContextSetWebProcessCountLimit :: + (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -} + -> Word32 + {- ^ /@limit@/: the maximum number of web processes -} + -> m () +webContextSetWebProcessCountLimit context limit = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + webkit_web_context_set_web_process_count_limit context' limit + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data WebContextSetWebProcessCountLimitMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebProcessCountLimitMethodInfo a signature where + overloadedMethod _ = webContextSetWebProcessCountLimit + +#endif + +-- method WebContext::get_default +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_context_get_default" webkit_web_context_get_default :: + IO (Ptr WebContext) + +{- | +Gets the default web context +-} +webContextGetDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m WebContext + {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebContext.WebContext' -} +webContextGetDefault = liftIO $ do + result <- webkit_web_context_get_default + checkUnexpectedReturnNULL "webContextGetDefault" result + result' <- (newObject WebContext) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/WebKit2/Objects/WebContext.hs-boot b/GI/WebKit2/Objects/WebContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebContext.hs-boot @@ -0,0 +1,152 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebContext 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 + +newtype WebContext = WebContext (ManagedPtr WebContext) +instance GObject WebContext where +class (GObject o, O.IsDescendantOf WebContext o) => IsWebContext o +instance (GObject o, O.IsDescendantOf WebContext o) => IsWebContext o +instance O.HasParentTypes WebContext +#if ENABLE_OVERLOADING +data WebContextLocalStorageDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebContextWebsiteDataManagerPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebContextAutomationStartedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebContextDownloadStartedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebContextInitializeNotificationPermissionsSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebContextInitializeWebExtensionsSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebContextAllowTlsCertificateForHostMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextClearCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextDownloadUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetCacheModelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetCookieManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetFaviconDatabaseMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetFaviconDatabaseDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetPluginsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetPluginsFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetProcessModelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetSecurityManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetSpellCheckingEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetSpellCheckingLanguagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetTlsErrorsPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetWebProcessCountLimitMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextGetWebsiteDataManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextInitializeNotificationPermissionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextIsAutomationAllowedMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextIsEphemeralMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextPrefetchDnsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextRegisterUriSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetAdditionalPluginsDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetAutomationAllowedMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetCacheModelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetDiskCacheDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetFaviconDatabaseDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetNetworkProxySettingsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetPreferredLanguagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetProcessModelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetSpellCheckingEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetSpellCheckingLanguagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetTlsErrorsPolicyMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetWebExtensionsDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetWebExtensionsInitializationUserDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebContextSetWebProcessCountLimitMethodInfo +#endif diff --git a/GI/WebKit2/Objects/WebInspector.hs b/GI/WebKit2/Objects/WebInspector.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebInspector.hs @@ -0,0 +1,1169 @@ + + +{- | +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.WebInspector + ( + +-- * Exported types + WebInspector(..) , + IsWebInspector , + toWebInspector , + noWebInspector , + + + -- * Methods +-- ** attach #method:attach# + +#if ENABLE_OVERLOADING + WebInspectorAttachMethodInfo , +#endif + webInspectorAttach , + + +-- ** close #method:close# + +#if ENABLE_OVERLOADING + WebInspectorCloseMethodInfo , +#endif + webInspectorClose , + + +-- ** detach #method:detach# + +#if ENABLE_OVERLOADING + WebInspectorDetachMethodInfo , +#endif + webInspectorDetach , + + +-- ** getAttachedHeight #method:getAttachedHeight# + +#if ENABLE_OVERLOADING + WebInspectorGetAttachedHeightMethodInfo , +#endif + webInspectorGetAttachedHeight , + + +-- ** getCanAttach #method:getCanAttach# + +#if ENABLE_OVERLOADING + WebInspectorGetCanAttachMethodInfo , +#endif + webInspectorGetCanAttach , + + +-- ** getInspectedUri #method:getInspectedUri# + +#if ENABLE_OVERLOADING + WebInspectorGetInspectedUriMethodInfo , +#endif + webInspectorGetInspectedUri , + + +-- ** getWebView #method:getWebView# + +#if ENABLE_OVERLOADING + WebInspectorGetWebViewMethodInfo , +#endif + webInspectorGetWebView , + + +-- ** isAttached #method:isAttached# + +#if ENABLE_OVERLOADING + WebInspectorIsAttachedMethodInfo , +#endif + webInspectorIsAttached , + + +-- ** show #method:show# + +#if ENABLE_OVERLOADING + WebInspectorShowMethodInfo , +#endif + webInspectorShow , + + + + + -- * Properties +-- ** attachedHeight #attr:attachedHeight# +{- | The height that the inspector view should have when it is attached. +-} +#if ENABLE_OVERLOADING + WebInspectorAttachedHeightPropertyInfo , +#endif + getWebInspectorAttachedHeight , +#if ENABLE_OVERLOADING + webInspectorAttachedHeight , +#endif + + +-- ** canAttach #attr:canAttach# +{- | Whether the /@inspector@/ can be attached to the same window that contains +the inspected view. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + WebInspectorCanAttachPropertyInfo , +#endif + getWebInspectorCanAttach , +#if ENABLE_OVERLOADING + webInspectorCanAttach , +#endif + + +-- ** inspectedUri #attr:inspectedUri# +{- | The URI that is currently being inspected. +-} +#if ENABLE_OVERLOADING + WebInspectorInspectedUriPropertyInfo , +#endif + getWebInspectorInspectedUri , +#if ENABLE_OVERLOADING + webInspectorInspectedUri , +#endif + + + + + -- * Signals +-- ** attach #signal:attach# + + C_WebInspectorAttachCallback , + WebInspectorAttachCallback , +#if ENABLE_OVERLOADING + WebInspectorAttachSignalInfo , +#endif + afterWebInspectorAttach , + genClosure_WebInspectorAttach , + mk_WebInspectorAttachCallback , + noWebInspectorAttachCallback , + onWebInspectorAttach , + wrap_WebInspectorAttachCallback , + + +-- ** bringToFront #signal:bringToFront# + + C_WebInspectorBringToFrontCallback , + WebInspectorBringToFrontCallback , +#if ENABLE_OVERLOADING + WebInspectorBringToFrontSignalInfo , +#endif + afterWebInspectorBringToFront , + genClosure_WebInspectorBringToFront , + mk_WebInspectorBringToFrontCallback , + noWebInspectorBringToFrontCallback , + onWebInspectorBringToFront , + wrap_WebInspectorBringToFrontCallback , + + +-- ** closed #signal:closed# + + C_WebInspectorClosedCallback , + WebInspectorClosedCallback , +#if ENABLE_OVERLOADING + WebInspectorClosedSignalInfo , +#endif + afterWebInspectorClosed , + genClosure_WebInspectorClosed , + mk_WebInspectorClosedCallback , + noWebInspectorClosedCallback , + onWebInspectorClosed , + wrap_WebInspectorClosedCallback , + + +-- ** detach #signal:detach# + + C_WebInspectorDetachCallback , + WebInspectorDetachCallback , +#if ENABLE_OVERLOADING + WebInspectorDetachSignalInfo , +#endif + afterWebInspectorDetach , + genClosure_WebInspectorDetach , + mk_WebInspectorDetachCallback , + noWebInspectorDetachCallback , + onWebInspectorDetach , + wrap_WebInspectorDetachCallback , + + +-- ** openWindow #signal:openWindow# + + C_WebInspectorOpenWindowCallback , + WebInspectorOpenWindowCallback , +#if ENABLE_OVERLOADING + WebInspectorOpenWindowSignalInfo , +#endif + afterWebInspectorOpenWindow , + genClosure_WebInspectorOpenWindow , + mk_WebInspectorOpenWindowCallback , + noWebInspectorOpenWindowCallback , + onWebInspectorOpenWindow , + wrap_WebInspectorOpenWindowCallback , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Objects.WebViewBase as WebKit2.WebViewBase + +-- | Memory-managed wrapper type. +newtype WebInspector = WebInspector (ManagedPtr WebInspector) +foreign import ccall "webkit_web_inspector_get_type" + c_webkit_web_inspector_get_type :: IO GType + +instance GObject WebInspector where + gobjectType = c_webkit_web_inspector_get_type + + +-- | Type class for types which can be safely cast to `WebInspector`, for instance with `toWebInspector`. +class (GObject o, O.IsDescendantOf WebInspector o) => IsWebInspector o +instance (GObject o, O.IsDescendantOf WebInspector o) => IsWebInspector o + +instance O.HasParentTypes WebInspector +type instance O.ParentTypes WebInspector = '[GObject.Object.Object] + +-- | Cast to `WebInspector`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWebInspector :: (MonadIO m, IsWebInspector o) => o -> m WebInspector +toWebInspector = liftIO . unsafeCastTo WebInspector + +-- | A convenience alias for `Nothing` :: `Maybe` `WebInspector`. +noWebInspector :: Maybe WebInspector +noWebInspector = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWebInspectorMethod (t :: Symbol) (o :: *) :: * where + ResolveWebInspectorMethod "attach" o = WebInspectorAttachMethodInfo + ResolveWebInspectorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWebInspectorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWebInspectorMethod "close" o = WebInspectorCloseMethodInfo + ResolveWebInspectorMethod "detach" o = WebInspectorDetachMethodInfo + ResolveWebInspectorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWebInspectorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWebInspectorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWebInspectorMethod "isAttached" o = WebInspectorIsAttachedMethodInfo + ResolveWebInspectorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWebInspectorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWebInspectorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWebInspectorMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWebInspectorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWebInspectorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWebInspectorMethod "show" o = WebInspectorShowMethodInfo + ResolveWebInspectorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWebInspectorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWebInspectorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWebInspectorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWebInspectorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWebInspectorMethod "getAttachedHeight" o = WebInspectorGetAttachedHeightMethodInfo + ResolveWebInspectorMethod "getCanAttach" o = WebInspectorGetCanAttachMethodInfo + ResolveWebInspectorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWebInspectorMethod "getInspectedUri" o = WebInspectorGetInspectedUriMethodInfo + ResolveWebInspectorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWebInspectorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWebInspectorMethod "getWebView" o = WebInspectorGetWebViewMethodInfo + ResolveWebInspectorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWebInspectorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWebInspectorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebInspectorMethod t WebInspector, O.MethodInfo info WebInspector p) => OL.IsLabel t (WebInspector -> 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 WebInspector::attach +{- | +Emitted when the inspector is requested to be attached to the window +where the inspected web view is. +If this signal is not handled the inspector view will be automatically +attached to the inspected view, so you only need to handle this signal +if you want to attach the inspector view yourself (for example, to add +the inspector view to a browser tab). + +To prevent the inspector view from being attached you can connect to this +signal and simply return 'True'. +-} +type WebInspectorAttachCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorAttachCallback`@. +noWebInspectorAttachCallback :: Maybe WebInspectorAttachCallback +noWebInspectorAttachCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebInspectorAttachCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebInspectorAttachCallback`. +foreign import ccall "wrapper" + mk_WebInspectorAttachCallback :: C_WebInspectorAttachCallback -> IO (FunPtr C_WebInspectorAttachCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebInspectorAttach :: MonadIO m => WebInspectorAttachCallback -> m (GClosure C_WebInspectorAttachCallback) +genClosure_WebInspectorAttach cb = liftIO $ do + let cb' = wrap_WebInspectorAttachCallback cb + mk_WebInspectorAttachCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebInspectorAttachCallback` into a `C_WebInspectorAttachCallback`. +wrap_WebInspectorAttachCallback :: + WebInspectorAttachCallback -> + C_WebInspectorAttachCallback +wrap_WebInspectorAttachCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@attach@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webInspector #attach callback +@ +-} +onWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId +onWebInspectorAttach obj cb = liftIO $ do + let cb' = wrap_WebInspectorAttachCallback cb + cb'' <- mk_WebInspectorAttachCallback cb' + connectSignalFunPtr obj "attach" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@attach@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webInspector #attach callback +@ +-} +afterWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId +afterWebInspectorAttach obj cb = liftIO $ do + let cb' = wrap_WebInspectorAttachCallback cb + cb'' <- mk_WebInspectorAttachCallback cb' + connectSignalFunPtr obj "attach" cb'' SignalConnectAfter + + +-- signal WebInspector::bring-to-front +{- | +Emitted when the inspector should be shown. + +If the inspector is not attached the inspector window should be shown +on top of any other windows. +If the inspector is attached the inspector view should be made visible. +For example, if the inspector view is attached using a tab in a browser +window, the browser window should be raised and the tab containing the +inspector view should be the active one. +In both cases, if this signal is not handled, the default implementation +calls 'GI.Gtk.Objects.Window.windowPresent' on the current toplevel 'GI.Gtk.Objects.Window.Window' of the +inspector view. +-} +type WebInspectorBringToFrontCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorBringToFrontCallback`@. +noWebInspectorBringToFrontCallback :: Maybe WebInspectorBringToFrontCallback +noWebInspectorBringToFrontCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebInspectorBringToFrontCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebInspectorBringToFrontCallback`. +foreign import ccall "wrapper" + mk_WebInspectorBringToFrontCallback :: C_WebInspectorBringToFrontCallback -> IO (FunPtr C_WebInspectorBringToFrontCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebInspectorBringToFront :: MonadIO m => WebInspectorBringToFrontCallback -> m (GClosure C_WebInspectorBringToFrontCallback) +genClosure_WebInspectorBringToFront cb = liftIO $ do + let cb' = wrap_WebInspectorBringToFrontCallback cb + mk_WebInspectorBringToFrontCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebInspectorBringToFrontCallback` into a `C_WebInspectorBringToFrontCallback`. +wrap_WebInspectorBringToFrontCallback :: + WebInspectorBringToFrontCallback -> + C_WebInspectorBringToFrontCallback +wrap_WebInspectorBringToFrontCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@bring-to-front@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webInspector #bringToFront callback +@ +-} +onWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId +onWebInspectorBringToFront obj cb = liftIO $ do + let cb' = wrap_WebInspectorBringToFrontCallback cb + cb'' <- mk_WebInspectorBringToFrontCallback cb' + connectSignalFunPtr obj "bring-to-front" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@bring-to-front@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webInspector #bringToFront callback +@ +-} +afterWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId +afterWebInspectorBringToFront obj cb = liftIO $ do + let cb' = wrap_WebInspectorBringToFrontCallback cb + cb'' <- mk_WebInspectorBringToFrontCallback cb' + connectSignalFunPtr obj "bring-to-front" cb'' SignalConnectAfter + + +-- signal WebInspector::closed +{- | +Emitted when the inspector page is closed. If you are using your own +inspector window, you should connect to this signal and destroy your +window. +-} +type WebInspectorClosedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorClosedCallback`@. +noWebInspectorClosedCallback :: Maybe WebInspectorClosedCallback +noWebInspectorClosedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebInspectorClosedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebInspectorClosedCallback`. +foreign import ccall "wrapper" + mk_WebInspectorClosedCallback :: C_WebInspectorClosedCallback -> IO (FunPtr C_WebInspectorClosedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebInspectorClosed :: MonadIO m => WebInspectorClosedCallback -> m (GClosure C_WebInspectorClosedCallback) +genClosure_WebInspectorClosed cb = liftIO $ do + let cb' = wrap_WebInspectorClosedCallback cb + mk_WebInspectorClosedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebInspectorClosedCallback` into a `C_WebInspectorClosedCallback`. +wrap_WebInspectorClosedCallback :: + WebInspectorClosedCallback -> + C_WebInspectorClosedCallback +wrap_WebInspectorClosedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@closed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webInspector #closed callback +@ +-} +onWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId +onWebInspectorClosed obj cb = liftIO $ do + let cb' = wrap_WebInspectorClosedCallback cb + cb'' <- mk_WebInspectorClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@closed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webInspector #closed callback +@ +-} +afterWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId +afterWebInspectorClosed obj cb = liftIO $ do + let cb' = wrap_WebInspectorClosedCallback cb + cb'' <- mk_WebInspectorClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' SignalConnectAfter + + +-- signal WebInspector::detach +{- | +Emitted when the inspector is requested to be detached from the window +it is currently attached to. The inspector is detached when the inspector page +is about to be closed, and this signal is emitted right before +'GI.WebKit2.Objects.WebInspector.WebInspector'::@/closed/@, or when the user clicks on the detach button +in the inspector view to show the inspector in a separate window. In this case +the signal 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/open-window/@ is emitted after this one. + +To prevent the inspector view from being detached you can connect to this +signal and simply return 'True'. +-} +type WebInspectorDetachCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorDetachCallback`@. +noWebInspectorDetachCallback :: Maybe WebInspectorDetachCallback +noWebInspectorDetachCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebInspectorDetachCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebInspectorDetachCallback`. +foreign import ccall "wrapper" + mk_WebInspectorDetachCallback :: C_WebInspectorDetachCallback -> IO (FunPtr C_WebInspectorDetachCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebInspectorDetach :: MonadIO m => WebInspectorDetachCallback -> m (GClosure C_WebInspectorDetachCallback) +genClosure_WebInspectorDetach cb = liftIO $ do + let cb' = wrap_WebInspectorDetachCallback cb + mk_WebInspectorDetachCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebInspectorDetachCallback` into a `C_WebInspectorDetachCallback`. +wrap_WebInspectorDetachCallback :: + WebInspectorDetachCallback -> + C_WebInspectorDetachCallback +wrap_WebInspectorDetachCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@detach@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webInspector #detach callback +@ +-} +onWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId +onWebInspectorDetach obj cb = liftIO $ do + let cb' = wrap_WebInspectorDetachCallback cb + cb'' <- mk_WebInspectorDetachCallback cb' + connectSignalFunPtr obj "detach" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@detach@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webInspector #detach callback +@ +-} +afterWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId +afterWebInspectorDetach obj cb = liftIO $ do + let cb' = wrap_WebInspectorDetachCallback cb + cb'' <- mk_WebInspectorDetachCallback cb' + connectSignalFunPtr obj "detach" cb'' SignalConnectAfter + + +-- signal WebInspector::open-window +{- | +Emitted when the inspector is requested to open in a separate window. +If this signal is not handled, a 'GI.Gtk.Objects.Window.Window' with the inspector will be +created and shown, so you only need to handle this signal if you want +to use your own window. +This signal is emitted after 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/detach/@ to show +the inspector in a separate window after being detached. + +To prevent the inspector from being shown you can connect to this +signal and simply return 'True' +-} +type WebInspectorOpenWindowCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebInspectorOpenWindowCallback`@. +noWebInspectorOpenWindowCallback :: Maybe WebInspectorOpenWindowCallback +noWebInspectorOpenWindowCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebInspectorOpenWindowCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebInspectorOpenWindowCallback`. +foreign import ccall "wrapper" + mk_WebInspectorOpenWindowCallback :: C_WebInspectorOpenWindowCallback -> IO (FunPtr C_WebInspectorOpenWindowCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebInspectorOpenWindow :: MonadIO m => WebInspectorOpenWindowCallback -> m (GClosure C_WebInspectorOpenWindowCallback) +genClosure_WebInspectorOpenWindow cb = liftIO $ do + let cb' = wrap_WebInspectorOpenWindowCallback cb + mk_WebInspectorOpenWindowCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebInspectorOpenWindowCallback` into a `C_WebInspectorOpenWindowCallback`. +wrap_WebInspectorOpenWindowCallback :: + WebInspectorOpenWindowCallback -> + C_WebInspectorOpenWindowCallback +wrap_WebInspectorOpenWindowCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@open-window@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webInspector #openWindow callback +@ +-} +onWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId +onWebInspectorOpenWindow obj cb = liftIO $ do + let cb' = wrap_WebInspectorOpenWindowCallback cb + cb'' <- mk_WebInspectorOpenWindowCallback cb' + connectSignalFunPtr obj "open-window" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@open-window@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webInspector #openWindow callback +@ +-} +afterWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId +afterWebInspectorOpenWindow obj cb = liftIO $ do + let cb' = wrap_WebInspectorOpenWindowCallback cb + cb'' <- mk_WebInspectorOpenWindowCallback cb' + connectSignalFunPtr obj "open-window" cb'' SignalConnectAfter + + +-- VVV Prop "attached-height" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@attached-height@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webInspector #attachedHeight +@ +-} +getWebInspectorAttachedHeight :: (MonadIO m, IsWebInspector o) => o -> m Word32 +getWebInspectorAttachedHeight obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "attached-height" + +#if ENABLE_OVERLOADING +data WebInspectorAttachedHeightPropertyInfo +instance AttrInfo WebInspectorAttachedHeightPropertyInfo where + type AttrAllowedOps WebInspectorAttachedHeightPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebInspectorAttachedHeightPropertyInfo = (~) () + type AttrBaseTypeConstraint WebInspectorAttachedHeightPropertyInfo = IsWebInspector + type AttrGetType WebInspectorAttachedHeightPropertyInfo = Word32 + type AttrLabel WebInspectorAttachedHeightPropertyInfo = "attached-height" + type AttrOrigin WebInspectorAttachedHeightPropertyInfo = WebInspector + attrGet _ = getWebInspectorAttachedHeight + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "can-attach" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@can-attach@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webInspector #canAttach +@ +-} +getWebInspectorCanAttach :: (MonadIO m, IsWebInspector o) => o -> m Bool +getWebInspectorCanAttach obj = liftIO $ B.Properties.getObjectPropertyBool obj "can-attach" + +#if ENABLE_OVERLOADING +data WebInspectorCanAttachPropertyInfo +instance AttrInfo WebInspectorCanAttachPropertyInfo where + type AttrAllowedOps WebInspectorCanAttachPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebInspectorCanAttachPropertyInfo = (~) () + type AttrBaseTypeConstraint WebInspectorCanAttachPropertyInfo = IsWebInspector + type AttrGetType WebInspectorCanAttachPropertyInfo = Bool + type AttrLabel WebInspectorCanAttachPropertyInfo = "can-attach" + type AttrOrigin WebInspectorCanAttachPropertyInfo = WebInspector + attrGet _ = getWebInspectorCanAttach + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "inspected-uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@inspected-uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webInspector #inspectedUri +@ +-} +getWebInspectorInspectedUri :: (MonadIO m, IsWebInspector o) => o -> m (Maybe T.Text) +getWebInspectorInspectedUri obj = liftIO $ B.Properties.getObjectPropertyString obj "inspected-uri" + +#if ENABLE_OVERLOADING +data WebInspectorInspectedUriPropertyInfo +instance AttrInfo WebInspectorInspectedUriPropertyInfo where + type AttrAllowedOps WebInspectorInspectedUriPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebInspectorInspectedUriPropertyInfo = (~) () + type AttrBaseTypeConstraint WebInspectorInspectedUriPropertyInfo = IsWebInspector + type AttrGetType WebInspectorInspectedUriPropertyInfo = (Maybe T.Text) + type AttrLabel WebInspectorInspectedUriPropertyInfo = "inspected-uri" + type AttrOrigin WebInspectorInspectedUriPropertyInfo = WebInspector + attrGet _ = getWebInspectorInspectedUri + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebInspector +type instance O.AttributeList WebInspector = WebInspectorAttributeList +type WebInspectorAttributeList = ('[ '("attachedHeight", WebInspectorAttachedHeightPropertyInfo), '("canAttach", WebInspectorCanAttachPropertyInfo), '("inspectedUri", WebInspectorInspectedUriPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +webInspectorAttachedHeight :: AttrLabelProxy "attachedHeight" +webInspectorAttachedHeight = AttrLabelProxy + +webInspectorCanAttach :: AttrLabelProxy "canAttach" +webInspectorCanAttach = AttrLabelProxy + +webInspectorInspectedUri :: AttrLabelProxy "inspectedUri" +webInspectorInspectedUri = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data WebInspectorAttachSignalInfo +instance SignalInfo WebInspectorAttachSignalInfo where + type HaskellCallbackType WebInspectorAttachSignalInfo = WebInspectorAttachCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebInspectorAttachCallback cb + cb'' <- mk_WebInspectorAttachCallback cb' + connectSignalFunPtr obj "attach" cb'' connectMode + +data WebInspectorBringToFrontSignalInfo +instance SignalInfo WebInspectorBringToFrontSignalInfo where + type HaskellCallbackType WebInspectorBringToFrontSignalInfo = WebInspectorBringToFrontCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebInspectorBringToFrontCallback cb + cb'' <- mk_WebInspectorBringToFrontCallback cb' + connectSignalFunPtr obj "bring-to-front" cb'' connectMode + +data WebInspectorClosedSignalInfo +instance SignalInfo WebInspectorClosedSignalInfo where + type HaskellCallbackType WebInspectorClosedSignalInfo = WebInspectorClosedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebInspectorClosedCallback cb + cb'' <- mk_WebInspectorClosedCallback cb' + connectSignalFunPtr obj "closed" cb'' connectMode + +data WebInspectorDetachSignalInfo +instance SignalInfo WebInspectorDetachSignalInfo where + type HaskellCallbackType WebInspectorDetachSignalInfo = WebInspectorDetachCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebInspectorDetachCallback cb + cb'' <- mk_WebInspectorDetachCallback cb' + connectSignalFunPtr obj "detach" cb'' connectMode + +data WebInspectorOpenWindowSignalInfo +instance SignalInfo WebInspectorOpenWindowSignalInfo where + type HaskellCallbackType WebInspectorOpenWindowSignalInfo = WebInspectorOpenWindowCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebInspectorOpenWindowCallback cb + cb'' <- mk_WebInspectorOpenWindowCallback cb' + connectSignalFunPtr obj "open-window" cb'' connectMode + +type instance O.SignalList WebInspector = WebInspectorSignalList +type WebInspectorSignalList = ('[ '("attach", WebInspectorAttachSignalInfo), '("bringToFront", WebInspectorBringToFrontSignalInfo), '("closed", WebInspectorClosedSignalInfo), '("detach", WebInspectorDetachSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("openWindow", WebInspectorOpenWindowSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WebInspector::attach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", 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_inspector_attach" webkit_web_inspector_attach :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO () + +{- | +Request /@inspector@/ to be attached. The signal 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/attach/@ +will be emitted. If the inspector is already attached it does nothing. +-} +webInspectorAttach :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m () +webInspectorAttach inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + webkit_web_inspector_attach inspector' + touchManagedPtr inspector + return () + +#if ENABLE_OVERLOADING +data WebInspectorAttachMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorAttachMethodInfo a signature where + overloadedMethod _ = webInspectorAttach + +#endif + +-- method WebInspector::close +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", 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_inspector_close" webkit_web_inspector_close :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO () + +{- | +Request /@inspector@/ to be closed. +-} +webInspectorClose :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m () +webInspectorClose inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + webkit_web_inspector_close inspector' + touchManagedPtr inspector + return () + +#if ENABLE_OVERLOADING +data WebInspectorCloseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorCloseMethodInfo a signature where + overloadedMethod _ = webInspectorClose + +#endif + +-- method WebInspector::detach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", 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_inspector_detach" webkit_web_inspector_detach :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO () + +{- | +Request /@inspector@/ to be detached. The signal 'GI.WebKit2.Objects.WebInspector.WebInspector'::@/detach/@ +will be emitted. If the inspector is already detached it does nothing. +-} +webInspectorDetach :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m () +webInspectorDetach inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + webkit_web_inspector_detach inspector' + touchManagedPtr inspector + return () + +#if ENABLE_OVERLOADING +data WebInspectorDetachMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorDetachMethodInfo a signature where + overloadedMethod _ = webInspectorDetach + +#endif + +-- method WebInspector::get_attached_height +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_inspector_get_attached_height" webkit_web_inspector_get_attached_height :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO Word32 + +{- | +Get the height that the inspector view should have when +it\'s attached. If the inspector view is not attached this +returns 0. +-} +webInspectorGetAttachedHeight :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m Word32 + {- ^ __Returns:__ the height of the inspector view when attached -} +webInspectorGetAttachedHeight inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + result <- webkit_web_inspector_get_attached_height inspector' + touchManagedPtr inspector + return result + +#if ENABLE_OVERLOADING +data WebInspectorGetAttachedHeightMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetAttachedHeightMethodInfo a signature where + overloadedMethod _ = webInspectorGetAttachedHeight + +#endif + +-- method WebInspector::get_can_attach +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_inspector_get_can_attach" webkit_web_inspector_get_can_attach :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO CInt + +{- | +Whether the /@inspector@/ can be attached to the same window that contains +the inspected view. + +/Since: 2.8/ +-} +webInspectorGetCanAttach :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m Bool + {- ^ __Returns:__ 'True' if there is enough room for the inspector view inside the + window that contains the inspected view, or 'False' otherwise. -} +webInspectorGetCanAttach inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + result <- webkit_web_inspector_get_can_attach inspector' + let result' = (/= 0) result + touchManagedPtr inspector + return result' + +#if ENABLE_OVERLOADING +data WebInspectorGetCanAttachMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetCanAttachMethodInfo a signature where + overloadedMethod _ = webInspectorGetCanAttach + +#endif + +-- method WebInspector::get_inspected_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", 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_inspector_get_inspected_uri" webkit_web_inspector_get_inspected_uri :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO CString + +{- | +Get the URI that is currently being inspected. This can be 'Nothing' if +nothing has been loaded yet in the inspected view, if the inspector +has been closed or when inspected view was loaded from a HTML string +instead of a URI. +-} +webInspectorGetInspectedUri :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the URI that is currently being inspected or 'Nothing' -} +webInspectorGetInspectedUri inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + result <- webkit_web_inspector_get_inspected_uri inspector' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr inspector + return maybeResult + +#if ENABLE_OVERLOADING +data WebInspectorGetInspectedUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetInspectedUriMethodInfo a signature where + overloadedMethod _ = webInspectorGetInspectedUri + +#endif + +-- method WebInspector::get_web_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebViewBase"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_inspector_get_web_view" webkit_web_inspector_get_web_view :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO (Ptr WebKit2.WebViewBase.WebViewBase) + +{- | +Get the 'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector. +This might be 'Nothing' if the inspector hasn\'t been loaded yet, +or it has been closed. +-} +webInspectorGetWebView :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m (Maybe WebKit2.WebViewBase.WebViewBase) + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebViewBase.WebViewBase' used to display the inspector or 'Nothing' -} +webInspectorGetWebView inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + result <- webkit_web_inspector_get_web_view inspector' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.WebViewBase.WebViewBase) result' + return result'' + touchManagedPtr inspector + return maybeResult + +#if ENABLE_OVERLOADING +data WebInspectorGetWebViewMethodInfo +instance (signature ~ (m (Maybe WebKit2.WebViewBase.WebViewBase)), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorGetWebViewMethodInfo a signature where + overloadedMethod _ = webInspectorGetWebView + +#endif + +-- method WebInspector::is_attached +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_inspector_is_attached" webkit_web_inspector_is_attached :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO CInt + +{- | +Whether the /@inspector@/ view is currently attached to the same window that contains +the inspected view. +-} +webInspectorIsAttached :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@inspector@/ is currently attached or 'False' otherwise -} +webInspectorIsAttached inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + result <- webkit_web_inspector_is_attached inspector' + let result' = (/= 0) result + touchManagedPtr inspector + return result' + +#if ENABLE_OVERLOADING +data WebInspectorIsAttachedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorIsAttachedMethodInfo a signature where + overloadedMethod _ = webInspectorIsAttached + +#endif + +-- method WebInspector::show +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "inspector", argType = TInterface (Name {namespace = "WebKit2", name = "WebInspector"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebInspector", 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_inspector_show" webkit_web_inspector_show :: + Ptr WebInspector -> -- inspector : TInterface (Name {namespace = "WebKit2", name = "WebInspector"}) + IO () + +{- | +Request /@inspector@/ to be shown. +-} +webInspectorShow :: + (B.CallStack.HasCallStack, MonadIO m, IsWebInspector a) => + a + {- ^ /@inspector@/: a 'GI.WebKit2.Objects.WebInspector.WebInspector' -} + -> m () +webInspectorShow inspector = liftIO $ do + inspector' <- unsafeManagedPtrCastPtr inspector + webkit_web_inspector_show inspector' + touchManagedPtr inspector + return () + +#if ENABLE_OVERLOADING +data WebInspectorShowMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebInspector a) => O.MethodInfo WebInspectorShowMethodInfo a signature where + overloadedMethod _ = webInspectorShow + +#endif + + diff --git a/GI/WebKit2/Objects/WebInspector.hs-boot b/GI/WebKit2/Objects/WebInspector.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebInspector.hs-boot @@ -0,0 +1,80 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebInspector 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 + +newtype WebInspector = WebInspector (ManagedPtr WebInspector) +instance GObject WebInspector where +class (GObject o, O.IsDescendantOf WebInspector o) => IsWebInspector o +instance (GObject o, O.IsDescendantOf WebInspector o) => IsWebInspector o +instance O.HasParentTypes WebInspector +#if ENABLE_OVERLOADING +data WebInspectorAttachedHeightPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorCanAttachPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorInspectedUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorAttachSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorBringToFrontSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorClosedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorDetachSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorOpenWindowSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorAttachMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorCloseMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorDetachMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorGetAttachedHeightMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorGetCanAttachMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorGetInspectedUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorGetWebViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorIsAttachedMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebInspectorShowMethodInfo +#endif diff --git a/GI/WebKit2/Objects/WebResource.hs b/GI/WebKit2/Objects/WebResource.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebResource.hs @@ -0,0 +1,951 @@ + + +{- | +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 + + diff --git a/GI/WebKit2/Objects/WebResource.hs-boot b/GI/WebKit2/Objects/WebResource.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebResource.hs-boot @@ -0,0 +1,62 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebResource 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 + +newtype WebResource = WebResource (ManagedPtr WebResource) +instance GObject WebResource where +class (GObject o, O.IsDescendantOf WebResource o) => IsWebResource o +instance (GObject o, O.IsDescendantOf WebResource o) => IsWebResource o +instance O.HasParentTypes WebResource +#if ENABLE_OVERLOADING +data WebResourceResponsePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceFailedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceFailedWithTlsErrorsSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceFinishedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceReceivedDataSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceSentRequestSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceGetDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceGetDataFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceGetResponseMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebResourceGetUriMethodInfo +#endif diff --git a/GI/WebKit2/Objects/WebView.hs b/GI/WebKit2/Objects/WebView.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebView.hs @@ -0,0 +1,7745 @@ + + +{- | +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.WebView + ( + +-- * Exported types + WebView(..) , + IsWebView , + toWebView , + noWebView , + + + -- * Methods +-- ** canExecuteEditingCommand #method:canExecuteEditingCommand# + +#if ENABLE_OVERLOADING + WebViewCanExecuteEditingCommandMethodInfo, +#endif + webViewCanExecuteEditingCommand , + + +-- ** canExecuteEditingCommandFinish #method:canExecuteEditingCommandFinish# + +#if ENABLE_OVERLOADING + WebViewCanExecuteEditingCommandFinishMethodInfo, +#endif + webViewCanExecuteEditingCommandFinish , + + +-- ** canGoBack #method:canGoBack# + +#if ENABLE_OVERLOADING + WebViewCanGoBackMethodInfo , +#endif + webViewCanGoBack , + + +-- ** canGoForward #method:canGoForward# + +#if ENABLE_OVERLOADING + WebViewCanGoForwardMethodInfo , +#endif + webViewCanGoForward , + + +-- ** canShowMimeType #method:canShowMimeType# + +#if ENABLE_OVERLOADING + WebViewCanShowMimeTypeMethodInfo , +#endif + webViewCanShowMimeType , + + +-- ** downloadUri #method:downloadUri# + +#if ENABLE_OVERLOADING + WebViewDownloadUriMethodInfo , +#endif + webViewDownloadUri , + + +-- ** executeEditingCommand #method:executeEditingCommand# + +#if ENABLE_OVERLOADING + WebViewExecuteEditingCommandMethodInfo , +#endif + webViewExecuteEditingCommand , + + +-- ** executeEditingCommandWithArgument #method:executeEditingCommandWithArgument# + +#if ENABLE_OVERLOADING + WebViewExecuteEditingCommandWithArgumentMethodInfo, +#endif + webViewExecuteEditingCommandWithArgument, + + +-- ** getBackForwardList #method:getBackForwardList# + +#if ENABLE_OVERLOADING + WebViewGetBackForwardListMethodInfo , +#endif + webViewGetBackForwardList , + + +-- ** getBackgroundColor #method:getBackgroundColor# + +#if ENABLE_OVERLOADING + WebViewGetBackgroundColorMethodInfo , +#endif + webViewGetBackgroundColor , + + +-- ** getContext #method:getContext# + +#if ENABLE_OVERLOADING + WebViewGetContextMethodInfo , +#endif + webViewGetContext , + + +-- ** getCustomCharset #method:getCustomCharset# + +#if ENABLE_OVERLOADING + WebViewGetCustomCharsetMethodInfo , +#endif + webViewGetCustomCharset , + + +-- ** getEditorState #method:getEditorState# + +#if ENABLE_OVERLOADING + WebViewGetEditorStateMethodInfo , +#endif + webViewGetEditorState , + + +-- ** getEstimatedLoadProgress #method:getEstimatedLoadProgress# + +#if ENABLE_OVERLOADING + WebViewGetEstimatedLoadProgressMethodInfo, +#endif + webViewGetEstimatedLoadProgress , + + +-- ** getFavicon #method:getFavicon# + +#if ENABLE_OVERLOADING + WebViewGetFaviconMethodInfo , +#endif + webViewGetFavicon , + + +-- ** getFindController #method:getFindController# + +#if ENABLE_OVERLOADING + WebViewGetFindControllerMethodInfo , +#endif + webViewGetFindController , + + +-- ** getInspector #method:getInspector# + +#if ENABLE_OVERLOADING + WebViewGetInspectorMethodInfo , +#endif + webViewGetInspector , + + +-- ** getMainResource #method:getMainResource# + +#if ENABLE_OVERLOADING + WebViewGetMainResourceMethodInfo , +#endif + webViewGetMainResource , + + +-- ** getPageId #method:getPageId# + +#if ENABLE_OVERLOADING + WebViewGetPageIdMethodInfo , +#endif + webViewGetPageId , + + +-- ** getSessionState #method:getSessionState# + +#if ENABLE_OVERLOADING + WebViewGetSessionStateMethodInfo , +#endif + webViewGetSessionState , + + +-- ** getSettings #method:getSettings# + +#if ENABLE_OVERLOADING + WebViewGetSettingsMethodInfo , +#endif + webViewGetSettings , + + +-- ** getSnapshot #method:getSnapshot# + +#if ENABLE_OVERLOADING + WebViewGetSnapshotMethodInfo , +#endif + webViewGetSnapshot , + + +-- ** getSnapshotFinish #method:getSnapshotFinish# + +#if ENABLE_OVERLOADING + WebViewGetSnapshotFinishMethodInfo , +#endif + webViewGetSnapshotFinish , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + WebViewGetTitleMethodInfo , +#endif + webViewGetTitle , + + +-- ** getTlsInfo #method:getTlsInfo# + +#if ENABLE_OVERLOADING + WebViewGetTlsInfoMethodInfo , +#endif + webViewGetTlsInfo , + + +-- ** getUri #method:getUri# + +#if ENABLE_OVERLOADING + WebViewGetUriMethodInfo , +#endif + webViewGetUri , + + +-- ** getUserContentManager #method:getUserContentManager# + +#if ENABLE_OVERLOADING + WebViewGetUserContentManagerMethodInfo , +#endif + webViewGetUserContentManager , + + +-- ** getWebsiteDataManager #method:getWebsiteDataManager# + +#if ENABLE_OVERLOADING + WebViewGetWebsiteDataManagerMethodInfo , +#endif + webViewGetWebsiteDataManager , + + +-- ** getWindowProperties #method:getWindowProperties# + +#if ENABLE_OVERLOADING + WebViewGetWindowPropertiesMethodInfo , +#endif + webViewGetWindowProperties , + + +-- ** getZoomLevel #method:getZoomLevel# + +#if ENABLE_OVERLOADING + WebViewGetZoomLevelMethodInfo , +#endif + webViewGetZoomLevel , + + +-- ** goBack #method:goBack# + +#if ENABLE_OVERLOADING + WebViewGoBackMethodInfo , +#endif + webViewGoBack , + + +-- ** goForward #method:goForward# + +#if ENABLE_OVERLOADING + WebViewGoForwardMethodInfo , +#endif + webViewGoForward , + + +-- ** goToBackForwardListItem #method:goToBackForwardListItem# + +#if ENABLE_OVERLOADING + WebViewGoToBackForwardListItemMethodInfo, +#endif + webViewGoToBackForwardListItem , + + +-- ** isControlledByAutomation #method:isControlledByAutomation# + +#if ENABLE_OVERLOADING + WebViewIsControlledByAutomationMethodInfo, +#endif + webViewIsControlledByAutomation , + + +-- ** isEditable #method:isEditable# + +#if ENABLE_OVERLOADING + WebViewIsEditableMethodInfo , +#endif + webViewIsEditable , + + +-- ** isEphemeral #method:isEphemeral# + +#if ENABLE_OVERLOADING + WebViewIsEphemeralMethodInfo , +#endif + webViewIsEphemeral , + + +-- ** isLoading #method:isLoading# + +#if ENABLE_OVERLOADING + WebViewIsLoadingMethodInfo , +#endif + webViewIsLoading , + + +-- ** isPlayingAudio #method:isPlayingAudio# + +#if ENABLE_OVERLOADING + WebViewIsPlayingAudioMethodInfo , +#endif + webViewIsPlayingAudio , + + +-- ** loadAlternateHtml #method:loadAlternateHtml# + +#if ENABLE_OVERLOADING + WebViewLoadAlternateHtmlMethodInfo , +#endif + webViewLoadAlternateHtml , + + +-- ** loadBytes #method:loadBytes# + +#if ENABLE_OVERLOADING + WebViewLoadBytesMethodInfo , +#endif + webViewLoadBytes , + + +-- ** loadHtml #method:loadHtml# + +#if ENABLE_OVERLOADING + WebViewLoadHtmlMethodInfo , +#endif + webViewLoadHtml , + + +-- ** loadPlainText #method:loadPlainText# + +#if ENABLE_OVERLOADING + WebViewLoadPlainTextMethodInfo , +#endif + webViewLoadPlainText , + + +-- ** loadRequest #method:loadRequest# + +#if ENABLE_OVERLOADING + WebViewLoadRequestMethodInfo , +#endif + webViewLoadRequest , + + +-- ** loadUri #method:loadUri# + +#if ENABLE_OVERLOADING + WebViewLoadUriMethodInfo , +#endif + webViewLoadUri , + + +-- ** new #method:new# + + webViewNew , + + +-- ** newWithContext #method:newWithContext# + + webViewNewWithContext , + + +-- ** newWithRelatedView #method:newWithRelatedView# + + webViewNewWithRelatedView , + + +-- ** newWithSettings #method:newWithSettings# + + webViewNewWithSettings , + + +-- ** newWithUserContentManager #method:newWithUserContentManager# + + webViewNewWithUserContentManager , + + +-- ** reload #method:reload# + +#if ENABLE_OVERLOADING + WebViewReloadMethodInfo , +#endif + webViewReload , + + +-- ** reloadBypassCache #method:reloadBypassCache# + +#if ENABLE_OVERLOADING + WebViewReloadBypassCacheMethodInfo , +#endif + webViewReloadBypassCache , + + +-- ** restoreSessionState #method:restoreSessionState# + +#if ENABLE_OVERLOADING + WebViewRestoreSessionStateMethodInfo , +#endif + webViewRestoreSessionState , + + +-- ** runJavascript #method:runJavascript# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptMethodInfo , +#endif + webViewRunJavascript , + + +-- ** runJavascriptFinish #method:runJavascriptFinish# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptFinishMethodInfo , +#endif + webViewRunJavascriptFinish , + + +-- ** runJavascriptFromGresource #method:runJavascriptFromGresource# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptFromGresourceMethodInfo, +#endif + webViewRunJavascriptFromGresource , + + +-- ** runJavascriptFromGresourceFinish #method:runJavascriptFromGresourceFinish# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptFromGresourceFinishMethodInfo, +#endif + webViewRunJavascriptFromGresourceFinish , + + +-- ** runJavascriptInWorld #method:runJavascriptInWorld# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptInWorldMethodInfo , +#endif + webViewRunJavascriptInWorld , + + +-- ** runJavascriptInWorldFinish #method:runJavascriptInWorldFinish# + +#if ENABLE_OVERLOADING + WebViewRunJavascriptInWorldFinishMethodInfo, +#endif + webViewRunJavascriptInWorldFinish , + + +-- ** save #method:save# + +#if ENABLE_OVERLOADING + WebViewSaveMethodInfo , +#endif + webViewSave , + + +-- ** saveFinish #method:saveFinish# + +#if ENABLE_OVERLOADING + WebViewSaveFinishMethodInfo , +#endif + webViewSaveFinish , + + +-- ** saveToFile #method:saveToFile# + +#if ENABLE_OVERLOADING + WebViewSaveToFileMethodInfo , +#endif + webViewSaveToFile , + + +-- ** saveToFileFinish #method:saveToFileFinish# + +#if ENABLE_OVERLOADING + WebViewSaveToFileFinishMethodInfo , +#endif + webViewSaveToFileFinish , + + +-- ** setBackgroundColor #method:setBackgroundColor# + +#if ENABLE_OVERLOADING + WebViewSetBackgroundColorMethodInfo , +#endif + webViewSetBackgroundColor , + + +-- ** setCustomCharset #method:setCustomCharset# + +#if ENABLE_OVERLOADING + WebViewSetCustomCharsetMethodInfo , +#endif + webViewSetCustomCharset , + + +-- ** setEditable #method:setEditable# + +#if ENABLE_OVERLOADING + WebViewSetEditableMethodInfo , +#endif + webViewSetEditable , + + +-- ** setSettings #method:setSettings# + +#if ENABLE_OVERLOADING + WebViewSetSettingsMethodInfo , +#endif + webViewSetSettings , + + +-- ** setZoomLevel #method:setZoomLevel# + +#if ENABLE_OVERLOADING + WebViewSetZoomLevelMethodInfo , +#endif + webViewSetZoomLevel , + + +-- ** stopLoading #method:stopLoading# + +#if ENABLE_OVERLOADING + WebViewStopLoadingMethodInfo , +#endif + webViewStopLoading , + + +-- ** tryClose #method:tryClose# + +#if ENABLE_OVERLOADING + WebViewTryCloseMethodInfo , +#endif + webViewTryClose , + + + + + -- * Properties +-- ** editable #attr:editable# +{- | Whether the pages loaded inside 'GI.WebKit2.Objects.WebView.WebView' are editable. For more +information see 'GI.WebKit2.Objects.WebView.webViewSetEditable'. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + WebViewEditablePropertyInfo , +#endif + constructWebViewEditable , + getWebViewEditable , + setWebViewEditable , +#if ENABLE_OVERLOADING + webViewEditable , +#endif + + +-- ** estimatedLoadProgress #attr:estimatedLoadProgress# +{- | An estimate of the percent completion for the current loading operation. +This value will range from 0.0 to 1.0 and, once a load completes, +will remain at 1.0 until a new load starts, at which point it +will be reset to 0.0. +The value is an estimate based on the total number of bytes expected +to be received for a document, including all its possible subresources +and child documents. +-} +#if ENABLE_OVERLOADING + WebViewEstimatedLoadProgressPropertyInfo, +#endif + getWebViewEstimatedLoadProgress , +#if ENABLE_OVERLOADING + webViewEstimatedLoadProgress , +#endif + + +-- ** favicon #attr:favicon# +{- | The favicon currently associated to the 'GI.WebKit2.Objects.WebView.WebView'. +See 'GI.WebKit2.Objects.WebView.webViewGetFavicon' for more details. +-} +#if ENABLE_OVERLOADING + WebViewFaviconPropertyInfo , +#endif + getWebViewFavicon , +#if ENABLE_OVERLOADING + webViewFavicon , +#endif + + +-- ** isControlledByAutomation #attr:isControlledByAutomation# +{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is controlled by automation. This should only be used when +creating a new 'GI.WebKit2.Objects.WebView.WebView' as a response to 'GI.WebKit2.Objects.AutomationSession.AutomationSession'::@/create-web-view/@ +signal request. + +/Since: 2.18/ +-} +#if ENABLE_OVERLOADING + WebViewIsControlledByAutomationPropertyInfo, +#endif + constructWebViewIsControlledByAutomation, + getWebViewIsControlledByAutomation , + + +-- ** isEphemeral #attr:isEphemeral# +{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is ephemeral. An ephemeral web view never writes +website data to the client storage, no matter what 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' +its context is using. This is normally used to implement private browsing mode. +This is a 'GI.GObject.Flags.ParamFlagsConstructOnly' property, so you have to create a ephemeral +'GI.WebKit2.Objects.WebView.WebView' and it can\'t be changed. Note that all 'GI.WebKit2.Objects.WebView.WebView'\s +created with an ephemeral 'GI.WebKit2.Objects.WebContext.WebContext' will be ephemeral automatically. +See also 'GI.WebKit2.Objects.WebContext.webContextNewEphemeral'. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + WebViewIsEphemeralPropertyInfo , +#endif + constructWebViewIsEphemeral , + getWebViewIsEphemeral , + + +-- ** isLoading #attr:isLoading# +{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is currently loading a page. This property becomes +'True' as soon as a new load operation is requested and before the +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal is emitted with 'GI.WebKit2.Enums.LoadEventStarted' and +at that point the active URI is the requested one. +When the load operation finishes the property is set to 'False' before +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with 'GI.WebKit2.Enums.LoadEventFinished'. +-} +#if ENABLE_OVERLOADING + WebViewIsLoadingPropertyInfo , +#endif + getWebViewIsLoading , + + +-- ** isPlayingAudio #attr:isPlayingAudio# +{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is currently playing audio from a page. +This property becomes 'True' as soon as web content starts playing any +kind of audio. When a page is no longer playing any kind of sound, +the property is set back to 'False'. + +/Since: 2.8/ +-} +#if ENABLE_OVERLOADING + WebViewIsPlayingAudioPropertyInfo , +#endif + getWebViewIsPlayingAudio , + + +-- ** relatedView #attr:relatedView# +{- | The related 'GI.WebKit2.Objects.WebView.WebView' used when creating the view to share the +same web process. This property is not readable because the related +web view is only valid during the object construction. + +/Since: 2.4/ +-} +#if ENABLE_OVERLOADING + WebViewRelatedViewPropertyInfo , +#endif + constructWebViewRelatedView , +#if ENABLE_OVERLOADING + webViewRelatedView , +#endif + + +-- ** settings #attr:settings# +{- | The 'GI.WebKit2.Objects.Settings.Settings' of the view. + +/Since: 2.6/ +-} +#if ENABLE_OVERLOADING + WebViewSettingsPropertyInfo , +#endif + constructWebViewSettings , + setWebViewSettings , +#if ENABLE_OVERLOADING + webViewSettings , +#endif + + +-- ** title #attr:title# +{- | The main frame document title of this 'GI.WebKit2.Objects.WebView.WebView'. If +the title has not been received yet, it will be 'Nothing'. +-} +#if ENABLE_OVERLOADING + WebViewTitlePropertyInfo , +#endif + getWebViewTitle , +#if ENABLE_OVERLOADING + webViewTitle , +#endif + + +-- ** uri #attr:uri# +{- | The current active URI of the 'GI.WebKit2.Objects.WebView.WebView'. +See 'GI.WebKit2.Objects.WebView.webViewGetUri' for more details. +-} +#if ENABLE_OVERLOADING + WebViewUriPropertyInfo , +#endif + getWebViewUri , +#if ENABLE_OVERLOADING + webViewUri , +#endif + + +-- ** userContentManager #attr:userContentManager# +{- | The 'GI.WebKit2.Objects.UserContentManager.UserContentManager' of the view. + +/Since: 2.6/ +-} +#if ENABLE_OVERLOADING + WebViewUserContentManagerPropertyInfo , +#endif + constructWebViewUserContentManager , + getWebViewUserContentManager , +#if ENABLE_OVERLOADING + webViewUserContentManager , +#endif + + +-- ** webContext #attr:webContext# +{- | The 'GI.WebKit2.Objects.WebContext.WebContext' of the view. +-} +#if ENABLE_OVERLOADING + WebViewWebContextPropertyInfo , +#endif + constructWebViewWebContext , + getWebViewWebContext , +#if ENABLE_OVERLOADING + webViewWebContext , +#endif + + +-- ** zoomLevel #attr:zoomLevel# +{- | The zoom level of the 'GI.WebKit2.Objects.WebView.WebView' content. +See 'GI.WebKit2.Objects.WebView.webViewSetZoomLevel' for more details. +-} +#if ENABLE_OVERLOADING + WebViewZoomLevelPropertyInfo , +#endif + constructWebViewZoomLevel , + getWebViewZoomLevel , + setWebViewZoomLevel , +#if ENABLE_OVERLOADING + webViewZoomLevel , +#endif + + + + + -- * Signals +-- ** authenticate #signal:authenticate# + + C_WebViewAuthenticateCallback , + WebViewAuthenticateCallback , +#if ENABLE_OVERLOADING + WebViewAuthenticateSignalInfo , +#endif + afterWebViewAuthenticate , + genClosure_WebViewAuthenticate , + mk_WebViewAuthenticateCallback , + noWebViewAuthenticateCallback , + onWebViewAuthenticate , + wrap_WebViewAuthenticateCallback , + + +-- ** close #signal:close# + + C_WebViewCloseCallback , + WebViewCloseCallback , +#if ENABLE_OVERLOADING + WebViewCloseSignalInfo , +#endif + afterWebViewClose , + genClosure_WebViewClose , + mk_WebViewCloseCallback , + noWebViewCloseCallback , + onWebViewClose , + wrap_WebViewCloseCallback , + + +-- ** contextMenu #signal:contextMenu# + + C_WebViewContextMenuCallback , + WebViewContextMenuCallback , +#if ENABLE_OVERLOADING + WebViewContextMenuSignalInfo , +#endif + afterWebViewContextMenu , + genClosure_WebViewContextMenu , + mk_WebViewContextMenuCallback , + noWebViewContextMenuCallback , + onWebViewContextMenu , + wrap_WebViewContextMenuCallback , + + +-- ** contextMenuDismissed #signal:contextMenuDismissed# + + C_WebViewContextMenuDismissedCallback , + WebViewContextMenuDismissedCallback , +#if ENABLE_OVERLOADING + WebViewContextMenuDismissedSignalInfo , +#endif + afterWebViewContextMenuDismissed , + genClosure_WebViewContextMenuDismissed , + mk_WebViewContextMenuDismissedCallback , + noWebViewContextMenuDismissedCallback , + onWebViewContextMenuDismissed , + wrap_WebViewContextMenuDismissedCallback, + + +-- ** create #signal:create# + + C_WebViewCreateCallback , + WebViewCreateCallback , +#if ENABLE_OVERLOADING + WebViewCreateSignalInfo , +#endif + afterWebViewCreate , + genClosure_WebViewCreate , + mk_WebViewCreateCallback , + noWebViewCreateCallback , + onWebViewCreate , + wrap_WebViewCreateCallback , + + +-- ** decidePolicy #signal:decidePolicy# + + C_WebViewDecidePolicyCallback , + WebViewDecidePolicyCallback , +#if ENABLE_OVERLOADING + WebViewDecidePolicySignalInfo , +#endif + afterWebViewDecidePolicy , + genClosure_WebViewDecidePolicy , + mk_WebViewDecidePolicyCallback , + noWebViewDecidePolicyCallback , + onWebViewDecidePolicy , + wrap_WebViewDecidePolicyCallback , + + +-- ** enterFullscreen #signal:enterFullscreen# + + C_WebViewEnterFullscreenCallback , + WebViewEnterFullscreenCallback , +#if ENABLE_OVERLOADING + WebViewEnterFullscreenSignalInfo , +#endif + afterWebViewEnterFullscreen , + genClosure_WebViewEnterFullscreen , + mk_WebViewEnterFullscreenCallback , + noWebViewEnterFullscreenCallback , + onWebViewEnterFullscreen , + wrap_WebViewEnterFullscreenCallback , + + +-- ** insecureContentDetected #signal:insecureContentDetected# + + C_WebViewInsecureContentDetectedCallback, + WebViewInsecureContentDetectedCallback , +#if ENABLE_OVERLOADING + WebViewInsecureContentDetectedSignalInfo, +#endif + afterWebViewInsecureContentDetected , + genClosure_WebViewInsecureContentDetected, + mk_WebViewInsecureContentDetectedCallback, + noWebViewInsecureContentDetectedCallback, + onWebViewInsecureContentDetected , + wrap_WebViewInsecureContentDetectedCallback, + + +-- ** leaveFullscreen #signal:leaveFullscreen# + + C_WebViewLeaveFullscreenCallback , + WebViewLeaveFullscreenCallback , +#if ENABLE_OVERLOADING + WebViewLeaveFullscreenSignalInfo , +#endif + afterWebViewLeaveFullscreen , + genClosure_WebViewLeaveFullscreen , + mk_WebViewLeaveFullscreenCallback , + noWebViewLeaveFullscreenCallback , + onWebViewLeaveFullscreen , + wrap_WebViewLeaveFullscreenCallback , + + +-- ** loadChanged #signal:loadChanged# + + C_WebViewLoadChangedCallback , + WebViewLoadChangedCallback , +#if ENABLE_OVERLOADING + WebViewLoadChangedSignalInfo , +#endif + afterWebViewLoadChanged , + genClosure_WebViewLoadChanged , + mk_WebViewLoadChangedCallback , + noWebViewLoadChangedCallback , + onWebViewLoadChanged , + wrap_WebViewLoadChangedCallback , + + +-- ** loadFailed #signal:loadFailed# + + C_WebViewLoadFailedCallback , + WebViewLoadFailedCallback , +#if ENABLE_OVERLOADING + WebViewLoadFailedSignalInfo , +#endif + afterWebViewLoadFailed , + genClosure_WebViewLoadFailed , + mk_WebViewLoadFailedCallback , + noWebViewLoadFailedCallback , + onWebViewLoadFailed , + wrap_WebViewLoadFailedCallback , + + +-- ** loadFailedWithTlsErrors #signal:loadFailedWithTlsErrors# + + C_WebViewLoadFailedWithTlsErrorsCallback, + WebViewLoadFailedWithTlsErrorsCallback , +#if ENABLE_OVERLOADING + WebViewLoadFailedWithTlsErrorsSignalInfo, +#endif + afterWebViewLoadFailedWithTlsErrors , + genClosure_WebViewLoadFailedWithTlsErrors, + mk_WebViewLoadFailedWithTlsErrorsCallback, + noWebViewLoadFailedWithTlsErrorsCallback, + onWebViewLoadFailedWithTlsErrors , + wrap_WebViewLoadFailedWithTlsErrorsCallback, + + +-- ** mouseTargetChanged #signal:mouseTargetChanged# + + C_WebViewMouseTargetChangedCallback , + WebViewMouseTargetChangedCallback , +#if ENABLE_OVERLOADING + WebViewMouseTargetChangedSignalInfo , +#endif + afterWebViewMouseTargetChanged , + genClosure_WebViewMouseTargetChanged , + mk_WebViewMouseTargetChangedCallback , + noWebViewMouseTargetChangedCallback , + onWebViewMouseTargetChanged , + wrap_WebViewMouseTargetChangedCallback , + + +-- ** permissionRequest #signal:permissionRequest# + + C_WebViewPermissionRequestCallback , + WebViewPermissionRequestCallback , +#if ENABLE_OVERLOADING + WebViewPermissionRequestSignalInfo , +#endif + afterWebViewPermissionRequest , + genClosure_WebViewPermissionRequest , + mk_WebViewPermissionRequestCallback , + noWebViewPermissionRequestCallback , + onWebViewPermissionRequest , + wrap_WebViewPermissionRequestCallback , + + +-- ** print #signal:print# + + C_WebViewPrintCallback , + WebViewPrintCallback , +#if ENABLE_OVERLOADING + WebViewPrintSignalInfo , +#endif + afterWebViewPrint , + genClosure_WebViewPrint , + mk_WebViewPrintCallback , + noWebViewPrintCallback , + onWebViewPrint , + wrap_WebViewPrintCallback , + + +-- ** readyToShow #signal:readyToShow# + + C_WebViewReadyToShowCallback , + WebViewReadyToShowCallback , +#if ENABLE_OVERLOADING + WebViewReadyToShowSignalInfo , +#endif + afterWebViewReadyToShow , + genClosure_WebViewReadyToShow , + mk_WebViewReadyToShowCallback , + noWebViewReadyToShowCallback , + onWebViewReadyToShow , + wrap_WebViewReadyToShowCallback , + + +-- ** resourceLoadStarted #signal:resourceLoadStarted# + + C_WebViewResourceLoadStartedCallback , + WebViewResourceLoadStartedCallback , +#if ENABLE_OVERLOADING + WebViewResourceLoadStartedSignalInfo , +#endif + afterWebViewResourceLoadStarted , + genClosure_WebViewResourceLoadStarted , + mk_WebViewResourceLoadStartedCallback , + noWebViewResourceLoadStartedCallback , + onWebViewResourceLoadStarted , + wrap_WebViewResourceLoadStartedCallback , + + +-- ** runAsModal #signal:runAsModal# + + C_WebViewRunAsModalCallback , + WebViewRunAsModalCallback , +#if ENABLE_OVERLOADING + WebViewRunAsModalSignalInfo , +#endif + afterWebViewRunAsModal , + genClosure_WebViewRunAsModal , + mk_WebViewRunAsModalCallback , + noWebViewRunAsModalCallback , + onWebViewRunAsModal , + wrap_WebViewRunAsModalCallback , + + +-- ** runColorChooser #signal:runColorChooser# + + C_WebViewRunColorChooserCallback , + WebViewRunColorChooserCallback , +#if ENABLE_OVERLOADING + WebViewRunColorChooserSignalInfo , +#endif + afterWebViewRunColorChooser , + genClosure_WebViewRunColorChooser , + mk_WebViewRunColorChooserCallback , + noWebViewRunColorChooserCallback , + onWebViewRunColorChooser , + wrap_WebViewRunColorChooserCallback , + + +-- ** runFileChooser #signal:runFileChooser# + + C_WebViewRunFileChooserCallback , + WebViewRunFileChooserCallback , +#if ENABLE_OVERLOADING + WebViewRunFileChooserSignalInfo , +#endif + afterWebViewRunFileChooser , + genClosure_WebViewRunFileChooser , + mk_WebViewRunFileChooserCallback , + noWebViewRunFileChooserCallback , + onWebViewRunFileChooser , + wrap_WebViewRunFileChooserCallback , + + +-- ** scriptDialog #signal:scriptDialog# + + C_WebViewScriptDialogCallback , + WebViewScriptDialogCallback , +#if ENABLE_OVERLOADING + WebViewScriptDialogSignalInfo , +#endif + afterWebViewScriptDialog , + genClosure_WebViewScriptDialog , + mk_WebViewScriptDialogCallback , + noWebViewScriptDialogCallback , + onWebViewScriptDialog , + wrap_WebViewScriptDialogCallback , + + +-- ** showNotification #signal:showNotification# + + C_WebViewShowNotificationCallback , + WebViewShowNotificationCallback , +#if ENABLE_OVERLOADING + WebViewShowNotificationSignalInfo , +#endif + afterWebViewShowNotification , + genClosure_WebViewShowNotification , + mk_WebViewShowNotificationCallback , + noWebViewShowNotificationCallback , + onWebViewShowNotification , + wrap_WebViewShowNotificationCallback , + + +-- ** showOptionMenu #signal:showOptionMenu# + + C_WebViewShowOptionMenuCallback , + WebViewShowOptionMenuCallback , +#if ENABLE_OVERLOADING + WebViewShowOptionMenuSignalInfo , +#endif + afterWebViewShowOptionMenu , + genClosure_WebViewShowOptionMenu , + mk_WebViewShowOptionMenuCallback , + noWebViewShowOptionMenuCallback , + onWebViewShowOptionMenu , + wrap_WebViewShowOptionMenuCallback , + + +-- ** submitForm #signal:submitForm# + + C_WebViewSubmitFormCallback , + WebViewSubmitFormCallback , +#if ENABLE_OVERLOADING + WebViewSubmitFormSignalInfo , +#endif + afterWebViewSubmitForm , + genClosure_WebViewSubmitForm , + mk_WebViewSubmitFormCallback , + noWebViewSubmitFormCallback , + onWebViewSubmitForm , + wrap_WebViewSubmitFormCallback , + + +-- ** webProcessCrashed #signal:webProcessCrashed# + + C_WebViewWebProcessCrashedCallback , + WebViewWebProcessCrashedCallback , +#if ENABLE_OVERLOADING + WebViewWebProcessCrashedSignalInfo , +#endif + afterWebViewWebProcessCrashed , + genClosure_WebViewWebProcessCrashed , + mk_WebViewWebProcessCrashedCallback , + noWebViewWebProcessCrashedCallback , + onWebViewWebProcessCrashed , + wrap_WebViewWebProcessCrashedCallback , + + +-- ** webProcessTerminated #signal:webProcessTerminated# + + C_WebViewWebProcessTerminatedCallback , + WebViewWebProcessTerminatedCallback , +#if ENABLE_OVERLOADING + WebViewWebProcessTerminatedSignalInfo , +#endif + afterWebViewWebProcessTerminated , + genClosure_WebViewWebProcessTerminated , + mk_WebViewWebProcessTerminatedCallback , + noWebViewWebProcessTerminatedCallback , + onWebViewWebProcessTerminated , + wrap_WebViewWebProcessTerminatedCallback, + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.Cairo.Structs.Surface as Cairo.Surface +import qualified GI.GLib.Structs.Bytes as GLib.Bytes +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA +import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle +import qualified GI.Gdk.Unions.Event as Gdk.Event +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.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.InputStream as Gio.InputStream +import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags +import {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.AuthenticationRequest as WebKit2.AuthenticationRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardList as WebKit2.BackForwardList +import {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardListItem as WebKit2.BackForwardListItem +import {-# SOURCE #-} qualified GI.WebKit2.Objects.ColorChooserRequest as WebKit2.ColorChooserRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.ContextMenu as WebKit2.ContextMenu +import {-# SOURCE #-} qualified GI.WebKit2.Objects.Download as WebKit2.Download +import {-# SOURCE #-} qualified GI.WebKit2.Objects.EditorState as WebKit2.EditorState +import {-# SOURCE #-} qualified GI.WebKit2.Objects.FileChooserRequest as WebKit2.FileChooserRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.FindController as WebKit2.FindController +import {-# SOURCE #-} qualified GI.WebKit2.Objects.FormSubmissionRequest as WebKit2.FormSubmissionRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.HitTestResult as WebKit2.HitTestResult +import {-# SOURCE #-} qualified GI.WebKit2.Objects.Notification as WebKit2.Notification +import {-# SOURCE #-} qualified GI.WebKit2.Objects.OptionMenu as WebKit2.OptionMenu +import {-# SOURCE #-} qualified GI.WebKit2.Objects.PolicyDecision as WebKit2.PolicyDecision +import {-# SOURCE #-} qualified GI.WebKit2.Objects.PrintOperation as WebKit2.PrintOperation +import {-# SOURCE #-} qualified GI.WebKit2.Objects.Settings as WebKit2.Settings +import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest +import {-# SOURCE #-} qualified GI.WebKit2.Objects.UserContentManager as WebKit2.UserContentManager +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebContext as WebKit2.WebContext +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebInspector as WebKit2.WebInspector +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebResource as WebKit2.WebResource +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebViewBase as WebKit2.WebViewBase +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebsiteDataManager as WebKit2.WebsiteDataManager +import {-# SOURCE #-} qualified GI.WebKit2.Objects.WindowProperties as WebKit2.WindowProperties +import {-# SOURCE #-} qualified GI.WebKit2.Structs.JavascriptResult as WebKit2.JavascriptResult +import {-# SOURCE #-} qualified GI.WebKit2.Structs.NavigationAction as WebKit2.NavigationAction +import {-# SOURCE #-} qualified GI.WebKit2.Structs.ScriptDialog as WebKit2.ScriptDialog +import {-# SOURCE #-} qualified GI.WebKit2.Structs.WebViewSessionState as WebKit2.WebViewSessionState + +-- | Memory-managed wrapper type. +newtype WebView = WebView (ManagedPtr WebView) +foreign import ccall "webkit_web_view_get_type" + c_webkit_web_view_get_type :: IO GType + +instance GObject WebView where + gobjectType = c_webkit_web_view_get_type + + +-- | Type class for types which can be safely cast to `WebView`, for instance with `toWebView`. +class (GObject o, O.IsDescendantOf WebView o) => IsWebView o +instance (GObject o, O.IsDescendantOf WebView o) => IsWebView o + +instance O.HasParentTypes WebView +type instance O.ParentTypes WebView = '[WebKit2.WebViewBase.WebViewBase, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable] + +-- | Cast to `WebView`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWebView :: (MonadIO m, IsWebView o) => o -> m WebView +toWebView = liftIO . unsafeCastTo WebView + +-- | A convenience alias for `Nothing` :: `Maybe` `WebView`. +noWebView :: Maybe WebView +noWebView = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWebViewMethod (t :: Symbol) (o :: *) :: * where + ResolveWebViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveWebViewMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveWebViewMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveWebViewMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveWebViewMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveWebViewMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveWebViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveWebViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveWebViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWebViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWebViewMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveWebViewMethod "canExecuteEditingCommand" o = WebViewCanExecuteEditingCommandMethodInfo + ResolveWebViewMethod "canExecuteEditingCommandFinish" o = WebViewCanExecuteEditingCommandFinishMethodInfo + ResolveWebViewMethod "canGoBack" o = WebViewCanGoBackMethodInfo + ResolveWebViewMethod "canGoForward" o = WebViewCanGoForwardMethodInfo + ResolveWebViewMethod "canShowMimeType" o = WebViewCanShowMimeTypeMethodInfo + ResolveWebViewMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveWebViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveWebViewMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveWebViewMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveWebViewMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveWebViewMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveWebViewMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveWebViewMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveWebViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveWebViewMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveWebViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveWebViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveWebViewMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveWebViewMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveWebViewMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveWebViewMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveWebViewMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveWebViewMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveWebViewMethod "downloadUri" o = WebViewDownloadUriMethodInfo + ResolveWebViewMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveWebViewMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveWebViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveWebViewMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveWebViewMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveWebViewMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveWebViewMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveWebViewMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveWebViewMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveWebViewMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveWebViewMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveWebViewMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveWebViewMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveWebViewMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveWebViewMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveWebViewMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveWebViewMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveWebViewMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveWebViewMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveWebViewMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveWebViewMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveWebViewMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveWebViewMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveWebViewMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveWebViewMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveWebViewMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveWebViewMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveWebViewMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveWebViewMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveWebViewMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveWebViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveWebViewMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveWebViewMethod "executeEditingCommand" o = WebViewExecuteEditingCommandMethodInfo + ResolveWebViewMethod "executeEditingCommandWithArgument" o = WebViewExecuteEditingCommandWithArgumentMethodInfo + ResolveWebViewMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveWebViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWebViewMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveWebViewMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveWebViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWebViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWebViewMethod "goBack" o = WebViewGoBackMethodInfo + ResolveWebViewMethod "goForward" o = WebViewGoForwardMethodInfo + ResolveWebViewMethod "goToBackForwardListItem" o = WebViewGoToBackForwardListItemMethodInfo + ResolveWebViewMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveWebViewMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveWebViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveWebViewMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveWebViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveWebViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveWebViewMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveWebViewMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveWebViewMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveWebViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveWebViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveWebViewMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveWebViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveWebViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveWebViewMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveWebViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveWebViewMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveWebViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveWebViewMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveWebViewMethod "isControlledByAutomation" o = WebViewIsControlledByAutomationMethodInfo + ResolveWebViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveWebViewMethod "isEditable" o = WebViewIsEditableMethodInfo + ResolveWebViewMethod "isEphemeral" o = WebViewIsEphemeralMethodInfo + ResolveWebViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWebViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveWebViewMethod "isLoading" o = WebViewIsLoadingMethodInfo + ResolveWebViewMethod "isPlayingAudio" o = WebViewIsPlayingAudioMethodInfo + ResolveWebViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveWebViewMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveWebViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveWebViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveWebViewMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveWebViewMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveWebViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveWebViewMethod "loadAlternateHtml" o = WebViewLoadAlternateHtmlMethodInfo + ResolveWebViewMethod "loadBytes" o = WebViewLoadBytesMethodInfo + ResolveWebViewMethod "loadHtml" o = WebViewLoadHtmlMethodInfo + ResolveWebViewMethod "loadPlainText" o = WebViewLoadPlainTextMethodInfo + ResolveWebViewMethod "loadRequest" o = WebViewLoadRequestMethodInfo + ResolveWebViewMethod "loadUri" o = WebViewLoadUriMethodInfo + ResolveWebViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveWebViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveWebViewMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveWebViewMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveWebViewMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveWebViewMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveWebViewMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveWebViewMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveWebViewMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveWebViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWebViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWebViewMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveWebViewMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveWebViewMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveWebViewMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveWebViewMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveWebViewMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveWebViewMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveWebViewMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveWebViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveWebViewMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveWebViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveWebViewMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveWebViewMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveWebViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveWebViewMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveWebViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveWebViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWebViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWebViewMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveWebViewMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveWebViewMethod "reload" o = WebViewReloadMethodInfo + ResolveWebViewMethod "reloadBypassCache" o = WebViewReloadBypassCacheMethodInfo + ResolveWebViewMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveWebViewMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveWebViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveWebViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveWebViewMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveWebViewMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveWebViewMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveWebViewMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveWebViewMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveWebViewMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveWebViewMethod "restoreSessionState" o = WebViewRestoreSessionStateMethodInfo + ResolveWebViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWebViewMethod "runJavascript" o = WebViewRunJavascriptMethodInfo + ResolveWebViewMethod "runJavascriptFinish" o = WebViewRunJavascriptFinishMethodInfo + ResolveWebViewMethod "runJavascriptFromGresource" o = WebViewRunJavascriptFromGresourceMethodInfo + ResolveWebViewMethod "runJavascriptFromGresourceFinish" o = WebViewRunJavascriptFromGresourceFinishMethodInfo + ResolveWebViewMethod "runJavascriptInWorld" o = WebViewRunJavascriptInWorldMethodInfo + ResolveWebViewMethod "runJavascriptInWorldFinish" o = WebViewRunJavascriptInWorldFinishMethodInfo + ResolveWebViewMethod "save" o = WebViewSaveMethodInfo + ResolveWebViewMethod "saveFinish" o = WebViewSaveFinishMethodInfo + ResolveWebViewMethod "saveToFile" o = WebViewSaveToFileMethodInfo + ResolveWebViewMethod "saveToFileFinish" o = WebViewSaveToFileFinishMethodInfo + ResolveWebViewMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveWebViewMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveWebViewMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveWebViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveWebViewMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveWebViewMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveWebViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveWebViewMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveWebViewMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveWebViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWebViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWebViewMethod "stopLoading" o = WebViewStopLoadingMethodInfo + ResolveWebViewMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveWebViewMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveWebViewMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveWebViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWebViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveWebViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveWebViewMethod "tryClose" o = WebViewTryCloseMethodInfo + ResolveWebViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveWebViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveWebViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveWebViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWebViewMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveWebViewMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveWebViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveWebViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWebViewMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveWebViewMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveWebViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveWebViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveWebViewMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveWebViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveWebViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveWebViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveWebViewMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveWebViewMethod "getBackForwardList" o = WebViewGetBackForwardListMethodInfo + ResolveWebViewMethod "getBackgroundColor" o = WebViewGetBackgroundColorMethodInfo + ResolveWebViewMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveWebViewMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveWebViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveWebViewMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveWebViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveWebViewMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveWebViewMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveWebViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveWebViewMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveWebViewMethod "getContext" o = WebViewGetContextMethodInfo + ResolveWebViewMethod "getCustomCharset" o = WebViewGetCustomCharsetMethodInfo + ResolveWebViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWebViewMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveWebViewMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveWebViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveWebViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveWebViewMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveWebViewMethod "getEditorState" o = WebViewGetEditorStateMethodInfo + ResolveWebViewMethod "getEstimatedLoadProgress" o = WebViewGetEstimatedLoadProgressMethodInfo + ResolveWebViewMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveWebViewMethod "getFavicon" o = WebViewGetFaviconMethodInfo + ResolveWebViewMethod "getFindController" o = WebViewGetFindControllerMethodInfo + ResolveWebViewMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveWebViewMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveWebViewMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveWebViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveWebViewMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveWebViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveWebViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveWebViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveWebViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveWebViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveWebViewMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveWebViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveWebViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveWebViewMethod "getInspector" o = WebViewGetInspectorMethodInfo + ResolveWebViewMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveWebViewMethod "getMainResource" o = WebViewGetMainResourceMethodInfo + ResolveWebViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveWebViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveWebViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveWebViewMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveWebViewMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveWebViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveWebViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveWebViewMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveWebViewMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveWebViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveWebViewMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveWebViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveWebViewMethod "getPageId" o = WebViewGetPageIdMethodInfo + ResolveWebViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveWebViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveWebViewMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveWebViewMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveWebViewMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveWebViewMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveWebViewMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveWebViewMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveWebViewMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveWebViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveWebViewMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveWebViewMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveWebViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWebViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWebViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveWebViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveWebViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveWebViewMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveWebViewMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveWebViewMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveWebViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveWebViewMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveWebViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveWebViewMethod "getSessionState" o = WebViewGetSessionStateMethodInfo + ResolveWebViewMethod "getSettings" o = WebViewGetSettingsMethodInfo + ResolveWebViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveWebViewMethod "getSnapshot" o = WebViewGetSnapshotMethodInfo + ResolveWebViewMethod "getSnapshotFinish" o = WebViewGetSnapshotFinishMethodInfo + ResolveWebViewMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveWebViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveWebViewMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveWebViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveWebViewMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveWebViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveWebViewMethod "getTitle" o = WebViewGetTitleMethodInfo + ResolveWebViewMethod "getTlsInfo" o = WebViewGetTlsInfoMethodInfo + ResolveWebViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveWebViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveWebViewMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveWebViewMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveWebViewMethod "getUri" o = WebViewGetUriMethodInfo + ResolveWebViewMethod "getUserContentManager" o = WebViewGetUserContentManagerMethodInfo + ResolveWebViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveWebViewMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveWebViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveWebViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveWebViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveWebViewMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveWebViewMethod "getWebsiteDataManager" o = WebViewGetWebsiteDataManagerMethodInfo + ResolveWebViewMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo + ResolveWebViewMethod "getWindowProperties" o = WebViewGetWindowPropertiesMethodInfo + ResolveWebViewMethod "getZoomLevel" o = WebViewGetZoomLevelMethodInfo + ResolveWebViewMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveWebViewMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveWebViewMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveWebViewMethod "setBackgroundColor" o = WebViewSetBackgroundColorMethodInfo + ResolveWebViewMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveWebViewMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveWebViewMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveWebViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveWebViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveWebViewMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveWebViewMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveWebViewMethod "setCustomCharset" o = WebViewSetCustomCharsetMethodInfo + ResolveWebViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWebViewMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveWebViewMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveWebViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveWebViewMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveWebViewMethod "setEditable" o = WebViewSetEditableMethodInfo + ResolveWebViewMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveWebViewMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveWebViewMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveWebViewMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveWebViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveWebViewMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveWebViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveWebViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveWebViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveWebViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveWebViewMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveWebViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveWebViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveWebViewMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveWebViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveWebViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveWebViewMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveWebViewMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveWebViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveWebViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveWebViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveWebViewMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveWebViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveWebViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveWebViewMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveWebViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWebViewMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveWebViewMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveWebViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveWebViewMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveWebViewMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveWebViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveWebViewMethod "setSettings" o = WebViewSetSettingsMethodInfo + ResolveWebViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveWebViewMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveWebViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveWebViewMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveWebViewMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveWebViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveWebViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveWebViewMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveWebViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveWebViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveWebViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveWebViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveWebViewMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveWebViewMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveWebViewMethod "setZoomLevel" o = WebViewSetZoomLevelMethodInfo + ResolveWebViewMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebViewMethod t WebView, O.MethodInfo info WebView p) => OL.IsLabel t (WebView -> 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 WebView::authenticate +{- | +This signal is emitted when the user is challenged with HTTP +authentication. To let the application access or supply +the credentials as well as to allow the client application +to either cancel the request or perform the authentication, +the signal will pass an instance of the +'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' in the /@request@/ argument. +To handle this signal asynchronously you should keep a ref +of the request and return 'True'. To disable HTTP authentication +entirely, connect to this signal and simply return 'True'. + +The default signal handler will run a default authentication +dialog asynchronously for the user to interact with. + +/Since: 2.2/ +-} +type WebViewAuthenticateCallback = + WebKit2.AuthenticationRequest.AuthenticationRequest + {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewAuthenticateCallback`@. +noWebViewAuthenticateCallback :: Maybe WebViewAuthenticateCallback +noWebViewAuthenticateCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewAuthenticateCallback = + Ptr () -> -- object + Ptr WebKit2.AuthenticationRequest.AuthenticationRequest -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewAuthenticateCallback`. +foreign import ccall "wrapper" + mk_WebViewAuthenticateCallback :: C_WebViewAuthenticateCallback -> IO (FunPtr C_WebViewAuthenticateCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewAuthenticate :: MonadIO m => WebViewAuthenticateCallback -> m (GClosure C_WebViewAuthenticateCallback) +genClosure_WebViewAuthenticate cb = liftIO $ do + let cb' = wrap_WebViewAuthenticateCallback cb + mk_WebViewAuthenticateCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewAuthenticateCallback` into a `C_WebViewAuthenticateCallback`. +wrap_WebViewAuthenticateCallback :: + WebViewAuthenticateCallback -> + C_WebViewAuthenticateCallback +wrap_WebViewAuthenticateCallback _cb _ request _ = do + request' <- (newObject WebKit2.AuthenticationRequest.AuthenticationRequest) request + result <- _cb request' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@authenticate@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #authenticate callback +@ +-} +onWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId +onWebViewAuthenticate obj cb = liftIO $ do + let cb' = wrap_WebViewAuthenticateCallback cb + cb'' <- mk_WebViewAuthenticateCallback cb' + connectSignalFunPtr obj "authenticate" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@authenticate@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #authenticate callback +@ +-} +afterWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId +afterWebViewAuthenticate obj cb = liftIO $ do + let cb' = wrap_WebViewAuthenticateCallback cb + cb'' <- mk_WebViewAuthenticateCallback cb' + connectSignalFunPtr obj "authenticate" cb'' SignalConnectAfter + + +-- signal WebView::close +{- | +Emitted when closing a 'GI.WebKit2.Objects.WebView.WebView' is requested. This occurs when a +call is made from JavaScript\'s \window.close\<\/function> function or +after trying to close the /@webView@/ with 'GI.WebKit2.Objects.WebView.webViewTryClose'. +It is the owner\'s responsibility to handle this signal to hide or +destroy the 'GI.WebKit2.Objects.WebView.WebView', if necessary. +-} +type WebViewCloseCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewCloseCallback`@. +noWebViewCloseCallback :: Maybe WebViewCloseCallback +noWebViewCloseCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewCloseCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewCloseCallback`. +foreign import ccall "wrapper" + mk_WebViewCloseCallback :: C_WebViewCloseCallback -> IO (FunPtr C_WebViewCloseCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewClose :: MonadIO m => WebViewCloseCallback -> m (GClosure C_WebViewCloseCallback) +genClosure_WebViewClose cb = liftIO $ do + let cb' = wrap_WebViewCloseCallback cb + mk_WebViewCloseCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewCloseCallback` into a `C_WebViewCloseCallback`. +wrap_WebViewCloseCallback :: + WebViewCloseCallback -> + C_WebViewCloseCallback +wrap_WebViewCloseCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@close@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #close callback +@ +-} +onWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId +onWebViewClose obj cb = liftIO $ do + let cb' = wrap_WebViewCloseCallback cb + cb'' <- mk_WebViewCloseCallback cb' + connectSignalFunPtr obj "close" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@close@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #close callback +@ +-} +afterWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId +afterWebViewClose obj cb = liftIO $ do + let cb' = wrap_WebViewCloseCallback cb + cb'' <- mk_WebViewCloseCallback cb' + connectSignalFunPtr obj "close" cb'' SignalConnectAfter + + +-- signal WebView::context-menu +{- | +Emitted when a context menu is about to be displayed to give the application +a chance to customize the proposed menu, prevent the menu from being displayed, +or build its own context menu. +\ +\\ + To customize the proposed menu you can use 'GI.WebKit2.Objects.ContextMenu.contextMenuPrepend', + 'GI.WebKit2.Objects.ContextMenu.contextMenuAppend' or 'GI.WebKit2.Objects.ContextMenu.contextMenuInsert' to add new + 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem'\s to /@contextMenu@/, 'GI.WebKit2.Objects.ContextMenu.contextMenuMoveItem' + to reorder existing items, or 'GI.WebKit2.Objects.ContextMenu.contextMenuRemove' to remove an + existing item. The signal handler should return 'False', and the menu represented + by /@contextMenu@/ will be shown. +\<\/para>\<\/listitem> +\\ + To prevent the menu from being displayed you can just connect to this signal + and return 'True' so that the proposed menu will not be shown. +\<\/para>\<\/listitem> +\\ + To build your own menu, you can remove all items from the proposed menu with + 'GI.WebKit2.Objects.ContextMenu.contextMenuRemoveAll', add your own items and return 'False' so + that the menu will be shown. You can also ignore the proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu', + build your own 'GI.Gtk.Objects.Menu.Menu' and return 'True' to prevent the proposed menu from being shown. +\<\/para>\<\/listitem> +\\ + If you just want the default menu to be shown always, simply don\'t connect to this + signal because showing the proposed context menu is the default behaviour. +\<\/para>\<\/listitem> +\<\/itemizedlist> + +The /@event@/ is expected to be one of the following types: +\ +\\ +a 'GI.Gdk.Structs.EventButton.EventButton' of type 'GI.Gdk.Enums.EventTypeButtonPress' when the context menu +was triggered with mouse. +\<\/para>\<\/listitem> +\\ +a 'GI.Gdk.Structs.EventKey.EventKey' of type 'GI.Gdk.Enums.EventTypeKeyPress' if the keyboard was used to show +the menu. +\<\/para>\<\/listitem> +\\ +a generic 'GI.Gdk.Unions.Event.Event' of type 'GI.Gdk.Enums.EventTypeNothing' when the 'GI.Gtk.Objects.Widget.Widget'::@/popup-menu/@ +signal was used to show the context menu. +\<\/para>\<\/listitem> +\<\/itemizedlist> + +If the signal handler returns 'False' the context menu represented by /@contextMenu@/ +will be shown, if it return 'True' the context menu will not be shown. + +The proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu' passed in /@contextMenu@/ argument is only valid +during the signal emission. +-} +type WebViewContextMenuCallback = + WebKit2.ContextMenu.ContextMenu + {- ^ /@contextMenu@/: the proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -} + -> Gdk.Event.Event + {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that triggered the context menu -} + -> WebKit2.HitTestResult.HitTestResult + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewContextMenuCallback`@. +noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback +noWebViewContextMenuCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewContextMenuCallback = + Ptr () -> -- object + Ptr WebKit2.ContextMenu.ContextMenu -> + Ptr Gdk.Event.Event -> + Ptr WebKit2.HitTestResult.HitTestResult -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewContextMenuCallback`. +foreign import ccall "wrapper" + mk_WebViewContextMenuCallback :: C_WebViewContextMenuCallback -> IO (FunPtr C_WebViewContextMenuCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewContextMenu :: MonadIO m => WebViewContextMenuCallback -> m (GClosure C_WebViewContextMenuCallback) +genClosure_WebViewContextMenu cb = liftIO $ do + let cb' = wrap_WebViewContextMenuCallback cb + mk_WebViewContextMenuCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewContextMenuCallback` into a `C_WebViewContextMenuCallback`. +wrap_WebViewContextMenuCallback :: + WebViewContextMenuCallback -> + C_WebViewContextMenuCallback +wrap_WebViewContextMenuCallback _cb _ contextMenu event hitTestResult _ = do + contextMenu' <- (newObject WebKit2.ContextMenu.ContextMenu) contextMenu + B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do + hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult + result <- _cb contextMenu' event' hitTestResult' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@context-menu@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #contextMenu callback +@ +-} +onWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId +onWebViewContextMenu obj cb = liftIO $ do + let cb' = wrap_WebViewContextMenuCallback cb + cb'' <- mk_WebViewContextMenuCallback cb' + connectSignalFunPtr obj "context-menu" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@context-menu@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #contextMenu callback +@ +-} +afterWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId +afterWebViewContextMenu obj cb = liftIO $ do + let cb' = wrap_WebViewContextMenuCallback cb + cb'' <- mk_WebViewContextMenuCallback cb' + connectSignalFunPtr obj "context-menu" cb'' SignalConnectAfter + + +-- signal WebView::context-menu-dismissed +{- | +Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/context-menu/@ signal, if the context menu is shown, +to notify that the context menu is dismissed. +-} +type WebViewContextMenuDismissedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewContextMenuDismissedCallback`@. +noWebViewContextMenuDismissedCallback :: Maybe WebViewContextMenuDismissedCallback +noWebViewContextMenuDismissedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewContextMenuDismissedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewContextMenuDismissedCallback`. +foreign import ccall "wrapper" + mk_WebViewContextMenuDismissedCallback :: C_WebViewContextMenuDismissedCallback -> IO (FunPtr C_WebViewContextMenuDismissedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewContextMenuDismissed :: MonadIO m => WebViewContextMenuDismissedCallback -> m (GClosure C_WebViewContextMenuDismissedCallback) +genClosure_WebViewContextMenuDismissed cb = liftIO $ do + let cb' = wrap_WebViewContextMenuDismissedCallback cb + mk_WebViewContextMenuDismissedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewContextMenuDismissedCallback` into a `C_WebViewContextMenuDismissedCallback`. +wrap_WebViewContextMenuDismissedCallback :: + WebViewContextMenuDismissedCallback -> + C_WebViewContextMenuDismissedCallback +wrap_WebViewContextMenuDismissedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@context-menu-dismissed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #contextMenuDismissed callback +@ +-} +onWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId +onWebViewContextMenuDismissed obj cb = liftIO $ do + let cb' = wrap_WebViewContextMenuDismissedCallback cb + cb'' <- mk_WebViewContextMenuDismissedCallback cb' + connectSignalFunPtr obj "context-menu-dismissed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@context-menu-dismissed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #contextMenuDismissed callback +@ +-} +afterWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId +afterWebViewContextMenuDismissed obj cb = liftIO $ do + let cb' = wrap_WebViewContextMenuDismissedCallback cb + cb'' <- mk_WebViewContextMenuDismissedCallback cb' + connectSignalFunPtr obj "context-menu-dismissed" cb'' SignalConnectAfter + + +-- signal WebView::create +{- | +Emitted when the creation of a new 'GI.WebKit2.Objects.WebView.WebView' is requested. +If this signal is handled the signal handler should return the +newly created 'GI.WebKit2.Objects.WebView.WebView'. + +The 'GI.WebKit2.Structs.NavigationAction.NavigationAction' parameter contains information about the +navigation action that triggered this signal. + +When using 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses' +process model, the new 'GI.WebKit2.Objects.WebView.WebView' should be related to +/@webView@/ to share the same web process, see 'GI.WebKit2.Objects.WebView.webViewNewWithRelatedView' +for more details. + +The new 'GI.WebKit2.Objects.WebView.WebView' should not be displayed to the user +until the 'GI.WebKit2.Objects.WebView.WebView'::@/ready-to-show/@ signal is emitted. +-} +type WebViewCreateCallback = + WebKit2.NavigationAction.NavigationAction + {- ^ /@navigationAction@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> IO Gtk.Widget.Widget + {- ^ __Returns:__ a newly allocated 'GI.WebKit2.Objects.WebView.WebView' widget + or 'Nothing' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewCreateCallback`@. +noWebViewCreateCallback :: Maybe WebViewCreateCallback +noWebViewCreateCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewCreateCallback = + Ptr () -> -- object + Ptr WebKit2.NavigationAction.NavigationAction -> + Ptr () -> -- user_data + IO (Ptr Gtk.Widget.Widget) + +-- | Generate a function pointer callable from C code, from a `C_WebViewCreateCallback`. +foreign import ccall "wrapper" + mk_WebViewCreateCallback :: C_WebViewCreateCallback -> IO (FunPtr C_WebViewCreateCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewCreate :: MonadIO m => WebViewCreateCallback -> m (GClosure C_WebViewCreateCallback) +genClosure_WebViewCreate cb = liftIO $ do + let cb' = wrap_WebViewCreateCallback cb + mk_WebViewCreateCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewCreateCallback` into a `C_WebViewCreateCallback`. +wrap_WebViewCreateCallback :: + WebViewCreateCallback -> + C_WebViewCreateCallback +wrap_WebViewCreateCallback _cb _ navigationAction _ = do + B.ManagedPtr.withTransient WebKit2.NavigationAction.NavigationAction navigationAction $ \navigationAction' -> do + result <- _cb navigationAction' + result' <- B.ManagedPtr.disownObject result + return result' + + +{- | +Connect a signal handler for the “@create@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #create callback +@ +-} +onWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId +onWebViewCreate obj cb = liftIO $ do + let cb' = wrap_WebViewCreateCallback cb + cb'' <- mk_WebViewCreateCallback cb' + connectSignalFunPtr obj "create" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@create@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #create callback +@ +-} +afterWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId +afterWebViewCreate obj cb = liftIO $ do + let cb' = wrap_WebViewCreateCallback cb + cb'' <- mk_WebViewCreateCallback cb' + connectSignalFunPtr obj "create" cb'' SignalConnectAfter + + +-- signal WebView::decide-policy +{- | +This signal is emitted when WebKit is requesting the client to decide a policy +decision, such as whether to navigate to a page, open a new window or whether or +not to download a resource. The 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' passed in the +/@decision@/ argument is a generic type, but should be casted to a more +specific type when making the decision. For example: + +\\ +static gboolean +decide_policy_cb (WebKitWebView *web_view, + WebKitPolicyDecision *decision, + WebKitPolicyDecisionType type) +{ + switch (type) { + case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + \/\* Make a policy decision here. *\\/ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: { + WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision); + \/\* Make a policy decision here. *\\/ + break; + } + case WEBKIT_POLICY_DECISION_TYPE_RESPONSE: + WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision); + \/\* Make a policy decision here. *\\/ + break; + default: + \/\* Making no decision results in 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse'. *\\/ + return FALSE; + } + return TRUE; +} +\<\/programlisting>\<\/informalexample> + +It is possible to make policy decision asynchronously, by simply calling 'GI.GObject.Objects.Object.objectRef' +on the /@decision@/ argument and returning 'True' to block the default signal handler. +If the last reference is removed on a 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' and no decision has been +made explicitly, 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' will be the default policy decision. The +default signal handler will simply call 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse'. Only the first +policy decision chosen for a given 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' will have any affect. +-} +type WebViewDecidePolicyCallback = + WebKit2.PolicyDecision.PolicyDecision + {- ^ /@decision@/: the 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' -} + -> WebKit2.Enums.PolicyDecisionType + {- ^ /@decisionType@/: a 'GI.WebKit2.Enums.PolicyDecisionType' denoting the type of /@decision@/ -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewDecidePolicyCallback`@. +noWebViewDecidePolicyCallback :: Maybe WebViewDecidePolicyCallback +noWebViewDecidePolicyCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewDecidePolicyCallback = + Ptr () -> -- object + Ptr WebKit2.PolicyDecision.PolicyDecision -> + CUInt -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewDecidePolicyCallback`. +foreign import ccall "wrapper" + mk_WebViewDecidePolicyCallback :: C_WebViewDecidePolicyCallback -> IO (FunPtr C_WebViewDecidePolicyCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewDecidePolicy :: MonadIO m => WebViewDecidePolicyCallback -> m (GClosure C_WebViewDecidePolicyCallback) +genClosure_WebViewDecidePolicy cb = liftIO $ do + let cb' = wrap_WebViewDecidePolicyCallback cb + mk_WebViewDecidePolicyCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewDecidePolicyCallback` into a `C_WebViewDecidePolicyCallback`. +wrap_WebViewDecidePolicyCallback :: + WebViewDecidePolicyCallback -> + C_WebViewDecidePolicyCallback +wrap_WebViewDecidePolicyCallback _cb _ decision decisionType _ = do + decision' <- (newObject WebKit2.PolicyDecision.PolicyDecision) decision + let decisionType' = (toEnum . fromIntegral) decisionType + result <- _cb decision' decisionType' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@decide-policy@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #decidePolicy callback +@ +-} +onWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId +onWebViewDecidePolicy obj cb = liftIO $ do + let cb' = wrap_WebViewDecidePolicyCallback cb + cb'' <- mk_WebViewDecidePolicyCallback cb' + connectSignalFunPtr obj "decide-policy" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@decide-policy@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #decidePolicy callback +@ +-} +afterWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId +afterWebViewDecidePolicy obj cb = liftIO $ do + let cb' = wrap_WebViewDecidePolicyCallback cb + cb'' <- mk_WebViewDecidePolicyCallback cb' + connectSignalFunPtr obj "decide-policy" cb'' SignalConnectAfter + + +-- signal WebView::enter-fullscreen +{- | +Emitted when JavaScript code calls +\element.webkitRequestFullScreen\<\/function>. If the +signal is not handled the 'GI.WebKit2.Objects.WebView.WebView' will proceed to full screen +its top level window. This signal can be used by client code to +request permission to the user prior doing the full screen +transition and eventually prepare the top-level window +(e.g. hide some widgets that would otherwise be part of the +full screen window). +-} +type WebViewEnterFullscreenCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to continue emission of the event. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewEnterFullscreenCallback`@. +noWebViewEnterFullscreenCallback :: Maybe WebViewEnterFullscreenCallback +noWebViewEnterFullscreenCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewEnterFullscreenCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewEnterFullscreenCallback`. +foreign import ccall "wrapper" + mk_WebViewEnterFullscreenCallback :: C_WebViewEnterFullscreenCallback -> IO (FunPtr C_WebViewEnterFullscreenCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewEnterFullscreen :: MonadIO m => WebViewEnterFullscreenCallback -> m (GClosure C_WebViewEnterFullscreenCallback) +genClosure_WebViewEnterFullscreen cb = liftIO $ do + let cb' = wrap_WebViewEnterFullscreenCallback cb + mk_WebViewEnterFullscreenCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewEnterFullscreenCallback` into a `C_WebViewEnterFullscreenCallback`. +wrap_WebViewEnterFullscreenCallback :: + WebViewEnterFullscreenCallback -> + C_WebViewEnterFullscreenCallback +wrap_WebViewEnterFullscreenCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@enter-fullscreen@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #enterFullscreen callback +@ +-} +onWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId +onWebViewEnterFullscreen obj cb = liftIO $ do + let cb' = wrap_WebViewEnterFullscreenCallback cb + cb'' <- mk_WebViewEnterFullscreenCallback cb' + connectSignalFunPtr obj "enter-fullscreen" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@enter-fullscreen@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #enterFullscreen callback +@ +-} +afterWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId +afterWebViewEnterFullscreen obj cb = liftIO $ do + let cb' = wrap_WebViewEnterFullscreenCallback cb + cb'' <- mk_WebViewEnterFullscreenCallback cb' + connectSignalFunPtr obj "enter-fullscreen" cb'' SignalConnectAfter + + +-- signal WebView::insecure-content-detected +{- | +This signal is emitted when insecure content has been detected +in a page loaded through a secure connection. This typically +means that a external resource from an unstrusted source has +been run or displayed, resulting in a mix of HTTPS and +non-HTTPS content. + +You can check the /@event@/ parameter to know exactly which kind +of event has been detected (see 'GI.WebKit2.Enums.InsecureContentEvent'). +-} +type WebViewInsecureContentDetectedCallback = + WebKit2.Enums.InsecureContentEvent + {- ^ /@event@/: the 'GI.WebKit2.Enums.InsecureContentEvent' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewInsecureContentDetectedCallback`@. +noWebViewInsecureContentDetectedCallback :: Maybe WebViewInsecureContentDetectedCallback +noWebViewInsecureContentDetectedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewInsecureContentDetectedCallback = + Ptr () -> -- object + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewInsecureContentDetectedCallback`. +foreign import ccall "wrapper" + mk_WebViewInsecureContentDetectedCallback :: C_WebViewInsecureContentDetectedCallback -> IO (FunPtr C_WebViewInsecureContentDetectedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewInsecureContentDetected :: MonadIO m => WebViewInsecureContentDetectedCallback -> m (GClosure C_WebViewInsecureContentDetectedCallback) +genClosure_WebViewInsecureContentDetected cb = liftIO $ do + let cb' = wrap_WebViewInsecureContentDetectedCallback cb + mk_WebViewInsecureContentDetectedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewInsecureContentDetectedCallback` into a `C_WebViewInsecureContentDetectedCallback`. +wrap_WebViewInsecureContentDetectedCallback :: + WebViewInsecureContentDetectedCallback -> + C_WebViewInsecureContentDetectedCallback +wrap_WebViewInsecureContentDetectedCallback _cb _ event _ = do + let event' = (toEnum . fromIntegral) event + _cb event' + + +{- | +Connect a signal handler for the “@insecure-content-detected@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #insecureContentDetected callback +@ +-} +onWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId +onWebViewInsecureContentDetected obj cb = liftIO $ do + let cb' = wrap_WebViewInsecureContentDetectedCallback cb + cb'' <- mk_WebViewInsecureContentDetectedCallback cb' + connectSignalFunPtr obj "insecure-content-detected" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@insecure-content-detected@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #insecureContentDetected callback +@ +-} +afterWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId +afterWebViewInsecureContentDetected obj cb = liftIO $ do + let cb' = wrap_WebViewInsecureContentDetectedCallback cb + cb'' <- mk_WebViewInsecureContentDetectedCallback cb' + connectSignalFunPtr obj "insecure-content-detected" cb'' SignalConnectAfter + + +-- signal WebView::leave-fullscreen +{- | +Emitted when the 'GI.WebKit2.Objects.WebView.WebView' is about to restore its top level +window out of its full screen state. This signal can be used by +client code to restore widgets hidden during the +'GI.WebKit2.Objects.WebView.WebView'::@/enter-fullscreen/@ stage for instance. +-} +type WebViewLeaveFullscreenCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to continue emission of the event. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLeaveFullscreenCallback`@. +noWebViewLeaveFullscreenCallback :: Maybe WebViewLeaveFullscreenCallback +noWebViewLeaveFullscreenCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewLeaveFullscreenCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewLeaveFullscreenCallback`. +foreign import ccall "wrapper" + mk_WebViewLeaveFullscreenCallback :: C_WebViewLeaveFullscreenCallback -> IO (FunPtr C_WebViewLeaveFullscreenCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewLeaveFullscreen :: MonadIO m => WebViewLeaveFullscreenCallback -> m (GClosure C_WebViewLeaveFullscreenCallback) +genClosure_WebViewLeaveFullscreen cb = liftIO $ do + let cb' = wrap_WebViewLeaveFullscreenCallback cb + mk_WebViewLeaveFullscreenCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewLeaveFullscreenCallback` into a `C_WebViewLeaveFullscreenCallback`. +wrap_WebViewLeaveFullscreenCallback :: + WebViewLeaveFullscreenCallback -> + C_WebViewLeaveFullscreenCallback +wrap_WebViewLeaveFullscreenCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@leave-fullscreen@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #leaveFullscreen callback +@ +-} +onWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId +onWebViewLeaveFullscreen obj cb = liftIO $ do + let cb' = wrap_WebViewLeaveFullscreenCallback cb + cb'' <- mk_WebViewLeaveFullscreenCallback cb' + connectSignalFunPtr obj "leave-fullscreen" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@leave-fullscreen@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #leaveFullscreen callback +@ +-} +afterWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId +afterWebViewLeaveFullscreen obj cb = liftIO $ do + let cb' = wrap_WebViewLeaveFullscreenCallback cb + cb'' <- mk_WebViewLeaveFullscreenCallback cb' + connectSignalFunPtr obj "leave-fullscreen" cb'' SignalConnectAfter + + +-- signal WebView::load-changed +{- | +Emitted when a load operation in /@webView@/ changes. +The signal is always emitted with 'GI.WebKit2.Enums.LoadEventStarted' when a +new load request is made and 'GI.WebKit2.Enums.LoadEventFinished' when the load +finishes successfully or due to an error. When the ongoing load +operation fails 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal is emitted +before 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with +'GI.WebKit2.Enums.LoadEventFinished'. +If a redirection is received from the server, this signal is emitted +with 'GI.WebKit2.Enums.LoadEventRedirected' after the initial emission with +'GI.WebKit2.Enums.LoadEventStarted' and before 'GI.WebKit2.Enums.LoadEventCommitted'. +When the page content starts arriving the signal is emitted with +'GI.WebKit2.Enums.LoadEventCommitted' event. + +You can handle this signal and use a switch to track any ongoing +load operation. + +\\ +static void web_view_load_changed (WebKitWebView *web_view, + WebKitLoadEvent load_event, + gpointer user_data) +{ + switch (load_event) { + case WEBKIT_LOAD_STARTED: + \/\* New load, we have now a provisional URI *\\/ + provisional_uri = webkit_web_view_get_uri (web_view); + \/\* Here we could start a spinner or update the + \* location bar with the provisional URI *\\/ + break; + case WEBKIT_LOAD_REDIRECTED: + redirected_uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_COMMITTED: + \/\* The load is being performed. Current URI is + \* the final one and it won\'t change unless a new + \* load is requested or a navigation within the + \* same page is performed *\\/ + uri = webkit_web_view_get_uri (web_view); + break; + case WEBKIT_LOAD_FINISHED: + \/\* Load finished, we can now stop the spinner *\\/ + break; + } +} +\<\/programlisting>\<\/informalexample> +-} +type WebViewLoadChangedCallback = + WebKit2.Enums.LoadEvent + {- ^ /@loadEvent@/: the 'GI.WebKit2.Enums.LoadEvent' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadChangedCallback`@. +noWebViewLoadChangedCallback :: Maybe WebViewLoadChangedCallback +noWebViewLoadChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewLoadChangedCallback = + Ptr () -> -- object + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewLoadChangedCallback`. +foreign import ccall "wrapper" + mk_WebViewLoadChangedCallback :: C_WebViewLoadChangedCallback -> IO (FunPtr C_WebViewLoadChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewLoadChanged :: MonadIO m => WebViewLoadChangedCallback -> m (GClosure C_WebViewLoadChangedCallback) +genClosure_WebViewLoadChanged cb = liftIO $ do + let cb' = wrap_WebViewLoadChangedCallback cb + mk_WebViewLoadChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewLoadChangedCallback` into a `C_WebViewLoadChangedCallback`. +wrap_WebViewLoadChangedCallback :: + WebViewLoadChangedCallback -> + C_WebViewLoadChangedCallback +wrap_WebViewLoadChangedCallback _cb _ loadEvent _ = do + let loadEvent' = (toEnum . fromIntegral) loadEvent + _cb loadEvent' + + +{- | +Connect a signal handler for the “@load-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #loadChanged callback +@ +-} +onWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId +onWebViewLoadChanged obj cb = liftIO $ do + let cb' = wrap_WebViewLoadChangedCallback cb + cb'' <- mk_WebViewLoadChangedCallback cb' + connectSignalFunPtr obj "load-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@load-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #loadChanged callback +@ +-} +afterWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId +afterWebViewLoadChanged obj cb = liftIO $ do + let cb' = wrap_WebViewLoadChangedCallback cb + cb'' <- mk_WebViewLoadChangedCallback cb' + connectSignalFunPtr obj "load-changed" cb'' SignalConnectAfter + + +-- signal WebView::load-failed +{- | +Emitted when an error occurs during a load operation. +If the error happened when starting to load data for a page +/@loadEvent@/ will be 'GI.WebKit2.Enums.LoadEventStarted'. If it happened while +loading a committed data source /@loadEvent@/ will be 'GI.WebKit2.Enums.LoadEventCommitted'. +Since a load error causes the load operation to finish, the signal +WebKitWebView::load-changed will always be emitted with +'GI.WebKit2.Enums.LoadEventFinished' event right after this one. + +By default, if the signal is not handled, a stock error page will be displayed. +You need to handle the signal if you want to provide your own error page. +-} +type WebViewLoadFailedCallback = + WebKit2.Enums.LoadEvent + {- ^ /@loadEvent@/: the 'GI.WebKit2.Enums.LoadEvent' of the load operation -} + -> T.Text + {- ^ /@failingUri@/: the URI that failed to load -} + -> GError + {- ^ /@error@/: the 'GError' that was triggered -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadFailedCallback`@. +noWebViewLoadFailedCallback :: Maybe WebViewLoadFailedCallback +noWebViewLoadFailedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewLoadFailedCallback = + Ptr () -> -- object + CUInt -> + CString -> + Ptr GError -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewLoadFailedCallback`. +foreign import ccall "wrapper" + mk_WebViewLoadFailedCallback :: C_WebViewLoadFailedCallback -> IO (FunPtr C_WebViewLoadFailedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewLoadFailed :: MonadIO m => WebViewLoadFailedCallback -> m (GClosure C_WebViewLoadFailedCallback) +genClosure_WebViewLoadFailed cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedCallback cb + mk_WebViewLoadFailedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewLoadFailedCallback` into a `C_WebViewLoadFailedCallback`. +wrap_WebViewLoadFailedCallback :: + WebViewLoadFailedCallback -> + C_WebViewLoadFailedCallback +wrap_WebViewLoadFailedCallback _cb _ loadEvent failingUri error_ _ = do + let loadEvent' = (toEnum . fromIntegral) loadEvent + failingUri' <- cstringToText failingUri + error_' <- (newBoxed GError) error_ + result <- _cb loadEvent' failingUri' error_' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@load-failed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #loadFailed callback +@ +-} +onWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId +onWebViewLoadFailed obj cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedCallback cb + cb'' <- mk_WebViewLoadFailedCallback cb' + connectSignalFunPtr obj "load-failed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@load-failed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #loadFailed callback +@ +-} +afterWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId +afterWebViewLoadFailed obj cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedCallback cb + cb'' <- mk_WebViewLoadFailedCallback cb' + connectSignalFunPtr obj "load-failed" cb'' SignalConnectAfter + + +-- signal WebView::load-failed-with-tls-errors +{- | +Emitted when a TLS error occurs during a load operation. +To allow an exception for this /@certificate@/ +and the host of /@failingUri@/ use 'GI.WebKit2.Objects.WebContext.webContextAllowTlsCertificateForHost'. + +To handle this signal asynchronously you should call 'GI.GObject.Objects.Object.objectRef' on /@certificate@/ +and return 'True'. + +If 'False' is returned, 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ will be emitted. The load +will finish regardless of the returned value. + +/Since: 2.6/ +-} +type WebViewLoadFailedWithTlsErrorsCallback = + T.Text + {- ^ /@failingUri@/: the URI that failed to load -} + -> 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 Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadFailedWithTlsErrorsCallback`@. +noWebViewLoadFailedWithTlsErrorsCallback :: Maybe WebViewLoadFailedWithTlsErrorsCallback +noWebViewLoadFailedWithTlsErrorsCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewLoadFailedWithTlsErrorsCallback = + Ptr () -> -- object + CString -> + Ptr Gio.TlsCertificate.TlsCertificate -> + CUInt -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewLoadFailedWithTlsErrorsCallback`. +foreign import ccall "wrapper" + mk_WebViewLoadFailedWithTlsErrorsCallback :: C_WebViewLoadFailedWithTlsErrorsCallback -> IO (FunPtr C_WebViewLoadFailedWithTlsErrorsCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewLoadFailedWithTlsErrors :: MonadIO m => WebViewLoadFailedWithTlsErrorsCallback -> m (GClosure C_WebViewLoadFailedWithTlsErrorsCallback) +genClosure_WebViewLoadFailedWithTlsErrors cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb + mk_WebViewLoadFailedWithTlsErrorsCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewLoadFailedWithTlsErrorsCallback` into a `C_WebViewLoadFailedWithTlsErrorsCallback`. +wrap_WebViewLoadFailedWithTlsErrorsCallback :: + WebViewLoadFailedWithTlsErrorsCallback -> + C_WebViewLoadFailedWithTlsErrorsCallback +wrap_WebViewLoadFailedWithTlsErrorsCallback _cb _ failingUri certificate errors _ = do + failingUri' <- cstringToText failingUri + certificate' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate + let errors' = wordToGFlags errors + result <- _cb failingUri' certificate' errors' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@load-failed-with-tls-errors@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #loadFailedWithTlsErrors callback +@ +-} +onWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId +onWebViewLoadFailedWithTlsErrors obj cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb + cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb' + connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@load-failed-with-tls-errors@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #loadFailedWithTlsErrors callback +@ +-} +afterWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId +afterWebViewLoadFailedWithTlsErrors obj cb = liftIO $ do + let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb + cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb' + connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' SignalConnectAfter + + +-- signal WebView::mouse-target-changed +{- | +This signal is emitted when the mouse cursor moves over an +element such as a link, image or a media element. To determine +what type of element the mouse cursor is over, a Hit Test is performed +on the current mouse coordinates and the result is passed in the +/@hitTestResult@/ argument. The /@modifiers@/ argument is a bitmask of +'GI.Gdk.Flags.ModifierType' flags indicating the state of modifier keys. +The signal is emitted again when the mouse is moved out of the +current element with a new /@hitTestResult@/. +-} +type WebViewMouseTargetChangedCallback = + WebKit2.HitTestResult.HitTestResult + {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -} + -> Word32 + {- ^ /@modifiers@/: a bitmask of 'GI.Gdk.Flags.ModifierType' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewMouseTargetChangedCallback`@. +noWebViewMouseTargetChangedCallback :: Maybe WebViewMouseTargetChangedCallback +noWebViewMouseTargetChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewMouseTargetChangedCallback = + Ptr () -> -- object + Ptr WebKit2.HitTestResult.HitTestResult -> + Word32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewMouseTargetChangedCallback`. +foreign import ccall "wrapper" + mk_WebViewMouseTargetChangedCallback :: C_WebViewMouseTargetChangedCallback -> IO (FunPtr C_WebViewMouseTargetChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewMouseTargetChanged :: MonadIO m => WebViewMouseTargetChangedCallback -> m (GClosure C_WebViewMouseTargetChangedCallback) +genClosure_WebViewMouseTargetChanged cb = liftIO $ do + let cb' = wrap_WebViewMouseTargetChangedCallback cb + mk_WebViewMouseTargetChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewMouseTargetChangedCallback` into a `C_WebViewMouseTargetChangedCallback`. +wrap_WebViewMouseTargetChangedCallback :: + WebViewMouseTargetChangedCallback -> + C_WebViewMouseTargetChangedCallback +wrap_WebViewMouseTargetChangedCallback _cb _ hitTestResult modifiers _ = do + hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult + _cb hitTestResult' modifiers + + +{- | +Connect a signal handler for the “@mouse-target-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #mouseTargetChanged callback +@ +-} +onWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId +onWebViewMouseTargetChanged obj cb = liftIO $ do + let cb' = wrap_WebViewMouseTargetChangedCallback cb + cb'' <- mk_WebViewMouseTargetChangedCallback cb' + connectSignalFunPtr obj "mouse-target-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@mouse-target-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #mouseTargetChanged callback +@ +-} +afterWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId +afterWebViewMouseTargetChanged obj cb = liftIO $ do + let cb' = wrap_WebViewMouseTargetChangedCallback cb + cb'' <- mk_WebViewMouseTargetChangedCallback cb' + connectSignalFunPtr obj "mouse-target-changed" cb'' SignalConnectAfter + + +-- signal WebView::permission-request +{- | +This signal is emitted when WebKit is requesting the client to +decide about a permission request, such as allowing the browser +to switch to fullscreen mode, sharing its location or similar +operations. + +A possible way to use this signal could be through a dialog +allowing the user decide what to do with the request: + +\\ +static gboolean permission_request_cb (WebKitWebView *web_view, + WebKitPermissionRequest *request, + GtkWindow *parent_window) +{ + GtkWidget *dialog = gtk_message_dialog_new (parent_window, + GTK_DIALOG_MODAL, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + \"Allow Permission Request?\"); + gtk_widget_show (dialog); + gint result = gtk_dialog_run (GTK_DIALOG (dialog)); + + switch (result) { + case GTK_RESPONSE_YES: + webkit_permission_request_allow (request); + break; + default: + webkit_permission_request_deny (request); + break; + } + gtk_widget_destroy (dialog); + + return TRUE; +} +\<\/programlisting>\<\/informalexample> + +It is possible to handle permission requests asynchronously, by +simply calling 'GI.GObject.Objects.Object.objectRef' on the /@request@/ argument and +returning 'True' to block the default signal handler. If the +last reference is removed on a 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' and the +request has not been handled, 'GI.WebKit2.Interfaces.PermissionRequest.permissionRequestDeny' +will be the default action. + +If the signal is not handled, the /@request@/ will be completed automatically +by the specific 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' that could allow or deny it. Check the +documentation of classes implementing 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' interface to know +their default action. +-} +type WebViewPermissionRequestCallback = + WebKit2.PermissionRequest.PermissionRequest + {- ^ /@request@/: the 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewPermissionRequestCallback`@. +noWebViewPermissionRequestCallback :: Maybe WebViewPermissionRequestCallback +noWebViewPermissionRequestCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewPermissionRequestCallback = + Ptr () -> -- object + Ptr WebKit2.PermissionRequest.PermissionRequest -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewPermissionRequestCallback`. +foreign import ccall "wrapper" + mk_WebViewPermissionRequestCallback :: C_WebViewPermissionRequestCallback -> IO (FunPtr C_WebViewPermissionRequestCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewPermissionRequest :: MonadIO m => WebViewPermissionRequestCallback -> m (GClosure C_WebViewPermissionRequestCallback) +genClosure_WebViewPermissionRequest cb = liftIO $ do + let cb' = wrap_WebViewPermissionRequestCallback cb + mk_WebViewPermissionRequestCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewPermissionRequestCallback` into a `C_WebViewPermissionRequestCallback`. +wrap_WebViewPermissionRequestCallback :: + WebViewPermissionRequestCallback -> + C_WebViewPermissionRequestCallback +wrap_WebViewPermissionRequestCallback _cb _ request _ = do + request' <- (newObject WebKit2.PermissionRequest.PermissionRequest) request + result <- _cb request' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@permission-request@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #permissionRequest callback +@ +-} +onWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId +onWebViewPermissionRequest obj cb = liftIO $ do + let cb' = wrap_WebViewPermissionRequestCallback cb + cb'' <- mk_WebViewPermissionRequestCallback cb' + connectSignalFunPtr obj "permission-request" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@permission-request@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #permissionRequest callback +@ +-} +afterWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId +afterWebViewPermissionRequest obj cb = liftIO $ do + let cb' = wrap_WebViewPermissionRequestCallback cb + cb'' <- mk_WebViewPermissionRequestCallback cb' + connectSignalFunPtr obj "permission-request" cb'' SignalConnectAfter + + +-- signal WebView::print +{- | +Emitted when printing is requested on /@webView@/, usually by a JavaScript call, +before the print dialog is shown. This signal can be used to set the initial +print settings and page setup of /@printOperation@/ to be used as default values in +the print dialog. You can call 'GI.WebKit2.Objects.PrintOperation.printOperationSetPrintSettings' and +'GI.WebKit2.Objects.PrintOperation.printOperationSetPageSetup' and then return 'False' to propagate the +event so that the print dialog is shown. + +You can connect to this signal and return 'True' to cancel the print operation +or implement your own print dialog. +-} +type WebViewPrintCallback = + WebKit2.PrintOperation.PrintOperation + {- ^ /@printOperation@/: the 'GI.WebKit2.Objects.PrintOperation.PrintOperation' that will handle the print request -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewPrintCallback`@. +noWebViewPrintCallback :: Maybe WebViewPrintCallback +noWebViewPrintCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewPrintCallback = + Ptr () -> -- object + Ptr WebKit2.PrintOperation.PrintOperation -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewPrintCallback`. +foreign import ccall "wrapper" + mk_WebViewPrintCallback :: C_WebViewPrintCallback -> IO (FunPtr C_WebViewPrintCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewPrint :: MonadIO m => WebViewPrintCallback -> m (GClosure C_WebViewPrintCallback) +genClosure_WebViewPrint cb = liftIO $ do + let cb' = wrap_WebViewPrintCallback cb + mk_WebViewPrintCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewPrintCallback` into a `C_WebViewPrintCallback`. +wrap_WebViewPrintCallback :: + WebViewPrintCallback -> + C_WebViewPrintCallback +wrap_WebViewPrintCallback _cb _ printOperation _ = do + printOperation' <- (newObject WebKit2.PrintOperation.PrintOperation) printOperation + result <- _cb printOperation' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@print@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #print callback +@ +-} +onWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId +onWebViewPrint obj cb = liftIO $ do + let cb' = wrap_WebViewPrintCallback cb + cb'' <- mk_WebViewPrintCallback cb' + connectSignalFunPtr obj "print" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@print@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #print callback +@ +-} +afterWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId +afterWebViewPrint obj cb = liftIO $ do + let cb' = wrap_WebViewPrintCallback cb + cb'' <- mk_WebViewPrintCallback cb' + connectSignalFunPtr obj "print" cb'' SignalConnectAfter + + +-- signal WebView::ready-to-show +{- | +Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/create/@ on the newly created 'GI.WebKit2.Objects.WebView.WebView' +when it should be displayed to the user. When this signal is emitted +all the information about how the window should look, including +size, position, whether the location, status and scrollbars +should be displayed, is already set on the 'GI.WebKit2.Objects.WindowProperties.WindowProperties' +of /@webView@/. See also 'GI.WebKit2.Objects.WebView.webViewGetWindowProperties'. +-} +type WebViewReadyToShowCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewReadyToShowCallback`@. +noWebViewReadyToShowCallback :: Maybe WebViewReadyToShowCallback +noWebViewReadyToShowCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewReadyToShowCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewReadyToShowCallback`. +foreign import ccall "wrapper" + mk_WebViewReadyToShowCallback :: C_WebViewReadyToShowCallback -> IO (FunPtr C_WebViewReadyToShowCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewReadyToShow :: MonadIO m => WebViewReadyToShowCallback -> m (GClosure C_WebViewReadyToShowCallback) +genClosure_WebViewReadyToShow cb = liftIO $ do + let cb' = wrap_WebViewReadyToShowCallback cb + mk_WebViewReadyToShowCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewReadyToShowCallback` into a `C_WebViewReadyToShowCallback`. +wrap_WebViewReadyToShowCallback :: + WebViewReadyToShowCallback -> + C_WebViewReadyToShowCallback +wrap_WebViewReadyToShowCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@ready-to-show@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #readyToShow callback +@ +-} +onWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId +onWebViewReadyToShow obj cb = liftIO $ do + let cb' = wrap_WebViewReadyToShowCallback cb + cb'' <- mk_WebViewReadyToShowCallback cb' + connectSignalFunPtr obj "ready-to-show" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@ready-to-show@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #readyToShow callback +@ +-} +afterWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId +afterWebViewReadyToShow obj cb = liftIO $ do + let cb' = wrap_WebViewReadyToShowCallback cb + cb'' <- mk_WebViewReadyToShowCallback cb' + connectSignalFunPtr obj "ready-to-show" cb'' SignalConnectAfter + + +-- signal WebView::resource-load-started +{- | +Emitted when a new resource is going to be loaded. The /@request@/ parameter +contains the 'GI.WebKit2.Objects.URIRequest.URIRequest' that will be sent to the server. +You can monitor the load operation by connecting to the different signals +of /@resource@/. +-} +type WebViewResourceLoadStartedCallback = + WebKit2.WebResource.WebResource + {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -} + -> WebKit2.URIRequest.URIRequest + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewResourceLoadStartedCallback`@. +noWebViewResourceLoadStartedCallback :: Maybe WebViewResourceLoadStartedCallback +noWebViewResourceLoadStartedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewResourceLoadStartedCallback = + Ptr () -> -- object + Ptr WebKit2.WebResource.WebResource -> + Ptr WebKit2.URIRequest.URIRequest -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewResourceLoadStartedCallback`. +foreign import ccall "wrapper" + mk_WebViewResourceLoadStartedCallback :: C_WebViewResourceLoadStartedCallback -> IO (FunPtr C_WebViewResourceLoadStartedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewResourceLoadStarted :: MonadIO m => WebViewResourceLoadStartedCallback -> m (GClosure C_WebViewResourceLoadStartedCallback) +genClosure_WebViewResourceLoadStarted cb = liftIO $ do + let cb' = wrap_WebViewResourceLoadStartedCallback cb + mk_WebViewResourceLoadStartedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewResourceLoadStartedCallback` into a `C_WebViewResourceLoadStartedCallback`. +wrap_WebViewResourceLoadStartedCallback :: + WebViewResourceLoadStartedCallback -> + C_WebViewResourceLoadStartedCallback +wrap_WebViewResourceLoadStartedCallback _cb _ resource request _ = do + resource' <- (newObject WebKit2.WebResource.WebResource) resource + request' <- (newObject WebKit2.URIRequest.URIRequest) request + _cb resource' request' + + +{- | +Connect a signal handler for the “@resource-load-started@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #resourceLoadStarted callback +@ +-} +onWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId +onWebViewResourceLoadStarted obj cb = liftIO $ do + let cb' = wrap_WebViewResourceLoadStartedCallback cb + cb'' <- mk_WebViewResourceLoadStartedCallback cb' + connectSignalFunPtr obj "resource-load-started" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@resource-load-started@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #resourceLoadStarted callback +@ +-} +afterWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId +afterWebViewResourceLoadStarted obj cb = liftIO $ do + let cb' = wrap_WebViewResourceLoadStartedCallback cb + cb'' <- mk_WebViewResourceLoadStartedCallback cb' + connectSignalFunPtr obj "resource-load-started" cb'' SignalConnectAfter + + +-- signal WebView::run-as-modal +{- | +Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/ready-to-show/@ on the newly +created 'GI.WebKit2.Objects.WebView.WebView' when JavaScript code calls +\window.showModalDialog\<\/function>. The purpose of +this signal is to allow the client application to prepare the +new view to behave as modal. Once the signal is emitted a new +main loop will be run to block user interaction in the parent +'GI.WebKit2.Objects.WebView.WebView' until the new dialog is closed. +-} +type WebViewRunAsModalCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunAsModalCallback`@. +noWebViewRunAsModalCallback :: Maybe WebViewRunAsModalCallback +noWebViewRunAsModalCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewRunAsModalCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewRunAsModalCallback`. +foreign import ccall "wrapper" + mk_WebViewRunAsModalCallback :: C_WebViewRunAsModalCallback -> IO (FunPtr C_WebViewRunAsModalCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewRunAsModal :: MonadIO m => WebViewRunAsModalCallback -> m (GClosure C_WebViewRunAsModalCallback) +genClosure_WebViewRunAsModal cb = liftIO $ do + let cb' = wrap_WebViewRunAsModalCallback cb + mk_WebViewRunAsModalCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewRunAsModalCallback` into a `C_WebViewRunAsModalCallback`. +wrap_WebViewRunAsModalCallback :: + WebViewRunAsModalCallback -> + C_WebViewRunAsModalCallback +wrap_WebViewRunAsModalCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@run-as-modal@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #runAsModal callback +@ +-} +onWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId +onWebViewRunAsModal obj cb = liftIO $ do + let cb' = wrap_WebViewRunAsModalCallback cb + cb'' <- mk_WebViewRunAsModalCallback cb' + connectSignalFunPtr obj "run-as-modal" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@run-as-modal@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #runAsModal callback +@ +-} +afterWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId +afterWebViewRunAsModal obj cb = liftIO $ do + let cb' = wrap_WebViewRunAsModalCallback cb + cb'' <- mk_WebViewRunAsModalCallback cb' + connectSignalFunPtr obj "run-as-modal" cb'' SignalConnectAfter + + +-- signal WebView::run-color-chooser +{- | +This signal is emitted when the user interacts with a <input +type=\'color\' \/> HTML element, requesting from WebKit to show +a dialog to select a color. To let the application know the details of +the color chooser, as well as to allow the client application to either +cancel the request or perform an actual color selection, the signal will +pass an instance of the 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' in the /@request@/ +argument. + +It is possible to handle this request asynchronously by increasing the +reference count of the request. + +The default signal handler will asynchronously run a regular +'GI.Gtk.Interfaces.ColorChooser.ColorChooser' for the user to interact with. + +/Since: 2.8/ +-} +type WebViewRunColorChooserCallback = + WebKit2.ColorChooserRequest.ColorChooserRequest + {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunColorChooserCallback`@. +noWebViewRunColorChooserCallback :: Maybe WebViewRunColorChooserCallback +noWebViewRunColorChooserCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewRunColorChooserCallback = + Ptr () -> -- object + Ptr WebKit2.ColorChooserRequest.ColorChooserRequest -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewRunColorChooserCallback`. +foreign import ccall "wrapper" + mk_WebViewRunColorChooserCallback :: C_WebViewRunColorChooserCallback -> IO (FunPtr C_WebViewRunColorChooserCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewRunColorChooser :: MonadIO m => WebViewRunColorChooserCallback -> m (GClosure C_WebViewRunColorChooserCallback) +genClosure_WebViewRunColorChooser cb = liftIO $ do + let cb' = wrap_WebViewRunColorChooserCallback cb + mk_WebViewRunColorChooserCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewRunColorChooserCallback` into a `C_WebViewRunColorChooserCallback`. +wrap_WebViewRunColorChooserCallback :: + WebViewRunColorChooserCallback -> + C_WebViewRunColorChooserCallback +wrap_WebViewRunColorChooserCallback _cb _ request _ = do + request' <- (newObject WebKit2.ColorChooserRequest.ColorChooserRequest) request + result <- _cb request' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@run-color-chooser@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #runColorChooser callback +@ +-} +onWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId +onWebViewRunColorChooser obj cb = liftIO $ do + let cb' = wrap_WebViewRunColorChooserCallback cb + cb'' <- mk_WebViewRunColorChooserCallback cb' + connectSignalFunPtr obj "run-color-chooser" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@run-color-chooser@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #runColorChooser callback +@ +-} +afterWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId +afterWebViewRunColorChooser obj cb = liftIO $ do + let cb' = wrap_WebViewRunColorChooserCallback cb + cb'' <- mk_WebViewRunColorChooserCallback cb' + connectSignalFunPtr obj "run-color-chooser" cb'' SignalConnectAfter + + +-- signal WebView::run-file-chooser +{- | +This signal is emitted when the user interacts with a <input +type=\'file\' \/> HTML element, requesting from WebKit to show +a dialog to select one or more files to be uploaded. To let the +application know the details of the file chooser, as well as to +allow the client application to either cancel the request or +perform an actual selection of files, the signal will pass an +instance of the 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' in the /@request@/ +argument. + +The default signal handler will asynchronously run a regular +'GI.Gtk.Objects.FileChooserDialog.FileChooserDialog' for the user to interact with. +-} +type WebViewRunFileChooserCallback = + WebKit2.FileChooserRequest.FileChooserRequest + {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunFileChooserCallback`@. +noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback +noWebViewRunFileChooserCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewRunFileChooserCallback = + Ptr () -> -- object + Ptr WebKit2.FileChooserRequest.FileChooserRequest -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewRunFileChooserCallback`. +foreign import ccall "wrapper" + mk_WebViewRunFileChooserCallback :: C_WebViewRunFileChooserCallback -> IO (FunPtr C_WebViewRunFileChooserCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewRunFileChooser :: MonadIO m => WebViewRunFileChooserCallback -> m (GClosure C_WebViewRunFileChooserCallback) +genClosure_WebViewRunFileChooser cb = liftIO $ do + let cb' = wrap_WebViewRunFileChooserCallback cb + mk_WebViewRunFileChooserCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewRunFileChooserCallback` into a `C_WebViewRunFileChooserCallback`. +wrap_WebViewRunFileChooserCallback :: + WebViewRunFileChooserCallback -> + C_WebViewRunFileChooserCallback +wrap_WebViewRunFileChooserCallback _cb _ request _ = do + request' <- (newObject WebKit2.FileChooserRequest.FileChooserRequest) request + result <- _cb request' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@run-file-chooser@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #runFileChooser callback +@ +-} +onWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId +onWebViewRunFileChooser obj cb = liftIO $ do + let cb' = wrap_WebViewRunFileChooserCallback cb + cb'' <- mk_WebViewRunFileChooserCallback cb' + connectSignalFunPtr obj "run-file-chooser" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@run-file-chooser@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #runFileChooser callback +@ +-} +afterWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId +afterWebViewRunFileChooser obj cb = liftIO $ do + let cb' = wrap_WebViewRunFileChooserCallback cb + cb'' <- mk_WebViewRunFileChooserCallback cb' + connectSignalFunPtr obj "run-file-chooser" cb'' SignalConnectAfter + + +-- signal WebView::script-dialog +{- | +Emitted when JavaScript code calls \window.alert\<\/function>, +\window.confirm\<\/function> or \window.prompt\<\/function>, +or when \onbeforeunload\<\/function> event is fired. +The /@dialog@/ parameter should be used to build the dialog. +If the signal is not handled a different dialog will be built and shown depending +on the dialog type: +\ +\\ + 'GI.WebKit2.Enums.ScriptDialogTypeAlert': message dialog with a single Close button. +\<\/para>\<\/listitem> +\\ + 'GI.WebKit2.Enums.ScriptDialogTypeConfirm': message dialog with OK and Cancel buttons. +\<\/para>\<\/listitem> +\\ + 'GI.WebKit2.Enums.ScriptDialogTypePrompt': message dialog with OK and Cancel buttons and + a text entry with the default text. +\<\/para>\<\/listitem> +\\ + 'GI.WebKit2.Enums.ScriptDialogTypeBeforeUnloadConfirm': message dialog with Stay and Leave buttons. +\<\/para>\<\/listitem> +\<\/itemizedlist> + +It is possible to handle the script dialog request asynchronously, by simply +caling 'GI.WebKit2.Structs.ScriptDialog.scriptDialogRef' on the /@dialog@/ argument and calling +'GI.WebKit2.Structs.ScriptDialog.scriptDialogClose' when done. +If the last reference is removed on a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' and the dialog has not been +closed, 'GI.WebKit2.Structs.ScriptDialog.scriptDialogClose' will be called. +-} +type WebViewScriptDialogCallback = + WebKit2.ScriptDialog.ScriptDialog + {- ^ /@dialog@/: the 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' to show -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewScriptDialogCallback`@. +noWebViewScriptDialogCallback :: Maybe WebViewScriptDialogCallback +noWebViewScriptDialogCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewScriptDialogCallback = + Ptr () -> -- object + Ptr WebKit2.ScriptDialog.ScriptDialog -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewScriptDialogCallback`. +foreign import ccall "wrapper" + mk_WebViewScriptDialogCallback :: C_WebViewScriptDialogCallback -> IO (FunPtr C_WebViewScriptDialogCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewScriptDialog :: MonadIO m => WebViewScriptDialogCallback -> m (GClosure C_WebViewScriptDialogCallback) +genClosure_WebViewScriptDialog cb = liftIO $ do + let cb' = wrap_WebViewScriptDialogCallback cb + mk_WebViewScriptDialogCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewScriptDialogCallback` into a `C_WebViewScriptDialogCallback`. +wrap_WebViewScriptDialogCallback :: + WebViewScriptDialogCallback -> + C_WebViewScriptDialogCallback +wrap_WebViewScriptDialogCallback _cb _ dialog _ = do + B.ManagedPtr.withTransient WebKit2.ScriptDialog.ScriptDialog dialog $ \dialog' -> do + result <- _cb dialog' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@script-dialog@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #scriptDialog callback +@ +-} +onWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId +onWebViewScriptDialog obj cb = liftIO $ do + let cb' = wrap_WebViewScriptDialogCallback cb + cb'' <- mk_WebViewScriptDialogCallback cb' + connectSignalFunPtr obj "script-dialog" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@script-dialog@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #scriptDialog callback +@ +-} +afterWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId +afterWebViewScriptDialog obj cb = liftIO $ do + let cb' = wrap_WebViewScriptDialogCallback cb + cb'' <- mk_WebViewScriptDialogCallback cb' + connectSignalFunPtr obj "script-dialog" cb'' SignalConnectAfter + + +-- signal WebView::show-notification +{- | +This signal is emitted when a notification should be presented to the +user. The /@notification@/ is kept alive until either: 1) the web page cancels it +or 2) a navigation happens. + +The default handler will emit a notification using libnotify, if built with +support for it. + +/Since: 2.8/ +-} +type WebViewShowNotificationCallback = + WebKit2.Notification.Notification + {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked. 'False' otherwise. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewShowNotificationCallback`@. +noWebViewShowNotificationCallback :: Maybe WebViewShowNotificationCallback +noWebViewShowNotificationCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewShowNotificationCallback = + Ptr () -> -- object + Ptr WebKit2.Notification.Notification -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewShowNotificationCallback`. +foreign import ccall "wrapper" + mk_WebViewShowNotificationCallback :: C_WebViewShowNotificationCallback -> IO (FunPtr C_WebViewShowNotificationCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewShowNotification :: MonadIO m => WebViewShowNotificationCallback -> m (GClosure C_WebViewShowNotificationCallback) +genClosure_WebViewShowNotification cb = liftIO $ do + let cb' = wrap_WebViewShowNotificationCallback cb + mk_WebViewShowNotificationCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewShowNotificationCallback` into a `C_WebViewShowNotificationCallback`. +wrap_WebViewShowNotificationCallback :: + WebViewShowNotificationCallback -> + C_WebViewShowNotificationCallback +wrap_WebViewShowNotificationCallback _cb _ notification _ = do + notification' <- (newObject WebKit2.Notification.Notification) notification + result <- _cb notification' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@show-notification@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #showNotification callback +@ +-} +onWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId +onWebViewShowNotification obj cb = liftIO $ do + let cb' = wrap_WebViewShowNotificationCallback cb + cb'' <- mk_WebViewShowNotificationCallback cb' + connectSignalFunPtr obj "show-notification" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@show-notification@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #showNotification callback +@ +-} +afterWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId +afterWebViewShowNotification obj cb = liftIO $ do + let cb' = wrap_WebViewShowNotificationCallback cb + cb'' <- mk_WebViewShowNotificationCallback cb' + connectSignalFunPtr obj "show-notification" cb'' SignalConnectAfter + + +-- signal WebView::show-option-menu +{- | +This signal is emitted when a select element in /@webView@/ needs to display a +dropdown menu. This signal can be used to show a custom menu, using /@menu@/ to get +the details of all items that should be displayed. The area of the element in the +'GI.WebKit2.Objects.WebView.WebView' is given as /@rectangle@/ parameter, it can be used to position the +menu. If this was triggered by a user interaction, like a mouse click, +/@event@/ parameter provides the 'GI.Gdk.Unions.Event.Event'. +To handle this signal asynchronously you should keep a ref of the /@menu@/. + +The default signal handler will pop up a 'GI.Gtk.Objects.Menu.Menu'. + +/Since: 2.18/ +-} +type WebViewShowOptionMenuCallback = + WebKit2.OptionMenu.OptionMenu + {- ^ /@menu@/: the 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -} + -> Gdk.Event.Event + {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that triggered the menu, or 'Nothing' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@rectangle@/: the option element area -} + -> IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewShowOptionMenuCallback`@. +noWebViewShowOptionMenuCallback :: Maybe WebViewShowOptionMenuCallback +noWebViewShowOptionMenuCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewShowOptionMenuCallback = + Ptr () -> -- object + Ptr WebKit2.OptionMenu.OptionMenu -> + Ptr Gdk.Event.Event -> + Ptr Gdk.Rectangle.Rectangle -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewShowOptionMenuCallback`. +foreign import ccall "wrapper" + mk_WebViewShowOptionMenuCallback :: C_WebViewShowOptionMenuCallback -> IO (FunPtr C_WebViewShowOptionMenuCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewShowOptionMenu :: MonadIO m => WebViewShowOptionMenuCallback -> m (GClosure C_WebViewShowOptionMenuCallback) +genClosure_WebViewShowOptionMenu cb = liftIO $ do + let cb' = wrap_WebViewShowOptionMenuCallback cb + mk_WebViewShowOptionMenuCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewShowOptionMenuCallback` into a `C_WebViewShowOptionMenuCallback`. +wrap_WebViewShowOptionMenuCallback :: + WebViewShowOptionMenuCallback -> + C_WebViewShowOptionMenuCallback +wrap_WebViewShowOptionMenuCallback _cb _ menu event rectangle _ = do + menu' <- (newObject WebKit2.OptionMenu.OptionMenu) menu + B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do + B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle rectangle $ \rectangle' -> do + result <- _cb menu' event' rectangle' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@show-option-menu@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #showOptionMenu callback +@ +-} +onWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId +onWebViewShowOptionMenu obj cb = liftIO $ do + let cb' = wrap_WebViewShowOptionMenuCallback cb + cb'' <- mk_WebViewShowOptionMenuCallback cb' + connectSignalFunPtr obj "show-option-menu" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@show-option-menu@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #showOptionMenu callback +@ +-} +afterWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId +afterWebViewShowOptionMenu obj cb = liftIO $ do + let cb' = wrap_WebViewShowOptionMenuCallback cb + cb'' <- mk_WebViewShowOptionMenuCallback cb' + connectSignalFunPtr obj "show-option-menu" cb'' SignalConnectAfter + + +-- signal WebView::submit-form +{- | +This signal is emitted when a form is about to be submitted. The /@request@/ +argument passed contains information about the text fields of the form. This +is typically used to store login information that can be used later to +pre-fill the form. +The form will not be submitted until 'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' is called. + +It is possible to handle the form submission request asynchronously, by +simply calling 'GI.GObject.Objects.Object.objectRef' on the /@request@/ argument and calling +'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' when done to continue with the form submission. +If the last reference is removed on a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' and the +form has not been submitted, 'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' will be called. +-} +type WebViewSubmitFormCallback = + WebKit2.FormSubmissionRequest.FormSubmissionRequest + {- ^ /@request@/: a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewSubmitFormCallback`@. +noWebViewSubmitFormCallback :: Maybe WebViewSubmitFormCallback +noWebViewSubmitFormCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewSubmitFormCallback = + Ptr () -> -- object + Ptr WebKit2.FormSubmissionRequest.FormSubmissionRequest -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewSubmitFormCallback`. +foreign import ccall "wrapper" + mk_WebViewSubmitFormCallback :: C_WebViewSubmitFormCallback -> IO (FunPtr C_WebViewSubmitFormCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewSubmitForm :: MonadIO m => WebViewSubmitFormCallback -> m (GClosure C_WebViewSubmitFormCallback) +genClosure_WebViewSubmitForm cb = liftIO $ do + let cb' = wrap_WebViewSubmitFormCallback cb + mk_WebViewSubmitFormCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewSubmitFormCallback` into a `C_WebViewSubmitFormCallback`. +wrap_WebViewSubmitFormCallback :: + WebViewSubmitFormCallback -> + C_WebViewSubmitFormCallback +wrap_WebViewSubmitFormCallback _cb _ request _ = do + request' <- (newObject WebKit2.FormSubmissionRequest.FormSubmissionRequest) request + _cb request' + + +{- | +Connect a signal handler for the “@submit-form@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #submitForm callback +@ +-} +onWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId +onWebViewSubmitForm obj cb = liftIO $ do + let cb' = wrap_WebViewSubmitFormCallback cb + cb'' <- mk_WebViewSubmitFormCallback cb' + connectSignalFunPtr obj "submit-form" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@submit-form@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #submitForm callback +@ +-} +afterWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId +afterWebViewSubmitForm obj cb = liftIO $ do + let cb' = wrap_WebViewSubmitFormCallback cb + cb'' <- mk_WebViewSubmitFormCallback cb' + connectSignalFunPtr obj "submit-form" cb'' SignalConnectAfter + + +-- signal WebView::web-process-crashed +{-# DEPRECATED WebViewWebProcessCrashedCallback ["(Since version 2.20)","Use WebKitWebView::web-process-terminated instead."] #-} +{- | +This signal is emitted when the web process crashes. +-} +type WebViewWebProcessCrashedCallback = + IO Bool + {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event. + 'False' to propagate the event further. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewWebProcessCrashedCallback`@. +noWebViewWebProcessCrashedCallback :: Maybe WebViewWebProcessCrashedCallback +noWebViewWebProcessCrashedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewWebProcessCrashedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_WebViewWebProcessCrashedCallback`. +foreign import ccall "wrapper" + mk_WebViewWebProcessCrashedCallback :: C_WebViewWebProcessCrashedCallback -> IO (FunPtr C_WebViewWebProcessCrashedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewWebProcessCrashed :: MonadIO m => WebViewWebProcessCrashedCallback -> m (GClosure C_WebViewWebProcessCrashedCallback) +genClosure_WebViewWebProcessCrashed cb = liftIO $ do + let cb' = wrap_WebViewWebProcessCrashedCallback cb + mk_WebViewWebProcessCrashedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewWebProcessCrashedCallback` into a `C_WebViewWebProcessCrashedCallback`. +wrap_WebViewWebProcessCrashedCallback :: + WebViewWebProcessCrashedCallback -> + C_WebViewWebProcessCrashedCallback +wrap_WebViewWebProcessCrashedCallback _cb _ _ = do + result <- _cb + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@web-process-crashed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #webProcessCrashed callback +@ +-} +onWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId +onWebViewWebProcessCrashed obj cb = liftIO $ do + let cb' = wrap_WebViewWebProcessCrashedCallback cb + cb'' <- mk_WebViewWebProcessCrashedCallback cb' + connectSignalFunPtr obj "web-process-crashed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@web-process-crashed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #webProcessCrashed callback +@ +-} +afterWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId +afterWebViewWebProcessCrashed obj cb = liftIO $ do + let cb' = wrap_WebViewWebProcessCrashedCallback cb + cb'' <- mk_WebViewWebProcessCrashedCallback cb' + connectSignalFunPtr obj "web-process-crashed" cb'' SignalConnectAfter + + +-- signal WebView::web-process-terminated +{- | +This signal is emitted when the web process terminates abnormally due +to /@reason@/. + +/Since: 2.20/ +-} +type WebViewWebProcessTerminatedCallback = + WebKit2.Enums.WebProcessTerminationReason + {- ^ /@reason@/: the a 'GI.WebKit2.Enums.WebProcessTerminationReason' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewWebProcessTerminatedCallback`@. +noWebViewWebProcessTerminatedCallback :: Maybe WebViewWebProcessTerminatedCallback +noWebViewWebProcessTerminatedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_WebViewWebProcessTerminatedCallback = + Ptr () -> -- object + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_WebViewWebProcessTerminatedCallback`. +foreign import ccall "wrapper" + mk_WebViewWebProcessTerminatedCallback :: C_WebViewWebProcessTerminatedCallback -> IO (FunPtr C_WebViewWebProcessTerminatedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_WebViewWebProcessTerminated :: MonadIO m => WebViewWebProcessTerminatedCallback -> m (GClosure C_WebViewWebProcessTerminatedCallback) +genClosure_WebViewWebProcessTerminated cb = liftIO $ do + let cb' = wrap_WebViewWebProcessTerminatedCallback cb + mk_WebViewWebProcessTerminatedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `WebViewWebProcessTerminatedCallback` into a `C_WebViewWebProcessTerminatedCallback`. +wrap_WebViewWebProcessTerminatedCallback :: + WebViewWebProcessTerminatedCallback -> + C_WebViewWebProcessTerminatedCallback +wrap_WebViewWebProcessTerminatedCallback _cb _ reason _ = do + let reason' = (toEnum . fromIntegral) reason + _cb reason' + + +{- | +Connect a signal handler for the “@web-process-terminated@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' webView #webProcessTerminated callback +@ +-} +onWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId +onWebViewWebProcessTerminated obj cb = liftIO $ do + let cb' = wrap_WebViewWebProcessTerminatedCallback cb + cb'' <- mk_WebViewWebProcessTerminatedCallback cb' + connectSignalFunPtr obj "web-process-terminated" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@web-process-terminated@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' webView #webProcessTerminated callback +@ +-} +afterWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId +afterWebViewWebProcessTerminated obj cb = liftIO $ do + let cb' = wrap_WebViewWebProcessTerminatedCallback cb + cb'' <- mk_WebViewWebProcessTerminatedCallback cb' + connectSignalFunPtr obj "web-process-terminated" cb'' SignalConnectAfter + + +-- VVV Prop "editable" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@editable@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #editable +@ +-} +getWebViewEditable :: (MonadIO m, IsWebView o) => o -> m Bool +getWebViewEditable obj = liftIO $ B.Properties.getObjectPropertyBool obj "editable" + +{- | +Set the value of the “@editable@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' webView [ #editable 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setWebViewEditable :: (MonadIO m, IsWebView o) => o -> Bool -> m () +setWebViewEditable obj val = liftIO $ B.Properties.setObjectPropertyBool obj "editable" val + +{- | +Construct a `GValueConstruct` with valid value for the “@editable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewEditable :: (IsWebView o) => Bool -> IO (GValueConstruct o) +constructWebViewEditable val = B.Properties.constructObjectPropertyBool "editable" val + +#if ENABLE_OVERLOADING +data WebViewEditablePropertyInfo +instance AttrInfo WebViewEditablePropertyInfo where + type AttrAllowedOps WebViewEditablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WebViewEditablePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WebViewEditablePropertyInfo = IsWebView + type AttrGetType WebViewEditablePropertyInfo = Bool + type AttrLabel WebViewEditablePropertyInfo = "editable" + type AttrOrigin WebViewEditablePropertyInfo = WebView + attrGet _ = getWebViewEditable + attrSet _ = setWebViewEditable + attrConstruct _ = constructWebViewEditable + attrClear _ = undefined +#endif + +-- VVV Prop "estimated-load-progress" + -- Type: TBasicType TDouble + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@estimated-load-progress@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #estimatedLoadProgress +@ +-} +getWebViewEstimatedLoadProgress :: (MonadIO m, IsWebView o) => o -> m Double +getWebViewEstimatedLoadProgress obj = liftIO $ B.Properties.getObjectPropertyDouble obj "estimated-load-progress" + +#if ENABLE_OVERLOADING +data WebViewEstimatedLoadProgressPropertyInfo +instance AttrInfo WebViewEstimatedLoadProgressPropertyInfo where + type AttrAllowedOps WebViewEstimatedLoadProgressPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebViewEstimatedLoadProgressPropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewEstimatedLoadProgressPropertyInfo = IsWebView + type AttrGetType WebViewEstimatedLoadProgressPropertyInfo = Double + type AttrLabel WebViewEstimatedLoadProgressPropertyInfo = "estimated-load-progress" + type AttrOrigin WebViewEstimatedLoadProgressPropertyInfo = WebView + attrGet _ = getWebViewEstimatedLoadProgress + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "favicon" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@favicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #favicon +@ +-} +getWebViewFavicon :: (MonadIO m, IsWebView o) => o -> m (Ptr ()) +getWebViewFavicon obj = liftIO $ B.Properties.getObjectPropertyPtr obj "favicon" + +#if ENABLE_OVERLOADING +data WebViewFaviconPropertyInfo +instance AttrInfo WebViewFaviconPropertyInfo where + type AttrAllowedOps WebViewFaviconPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebViewFaviconPropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewFaviconPropertyInfo = IsWebView + type AttrGetType WebViewFaviconPropertyInfo = (Ptr ()) + type AttrLabel WebViewFaviconPropertyInfo = "favicon" + type AttrOrigin WebViewFaviconPropertyInfo = WebView + attrGet _ = getWebViewFavicon + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "is-controlled-by-automation" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-controlled-by-automation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #isControlledByAutomation +@ +-} +getWebViewIsControlledByAutomation :: (MonadIO m, IsWebView o) => o -> m Bool +getWebViewIsControlledByAutomation obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-controlled-by-automation" + +{- | +Construct a `GValueConstruct` with valid value for the “@is-controlled-by-automation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewIsControlledByAutomation :: (IsWebView o) => Bool -> IO (GValueConstruct o) +constructWebViewIsControlledByAutomation val = B.Properties.constructObjectPropertyBool "is-controlled-by-automation" val + +#if ENABLE_OVERLOADING +data WebViewIsControlledByAutomationPropertyInfo +instance AttrInfo WebViewIsControlledByAutomationPropertyInfo where + type AttrAllowedOps WebViewIsControlledByAutomationPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WebViewIsControlledByAutomationPropertyInfo = (~) Bool + type AttrBaseTypeConstraint WebViewIsControlledByAutomationPropertyInfo = IsWebView + type AttrGetType WebViewIsControlledByAutomationPropertyInfo = Bool + type AttrLabel WebViewIsControlledByAutomationPropertyInfo = "is-controlled-by-automation" + type AttrOrigin WebViewIsControlledByAutomationPropertyInfo = WebView + attrGet _ = getWebViewIsControlledByAutomation + attrSet _ = undefined + attrConstruct _ = constructWebViewIsControlledByAutomation + attrClear _ = undefined +#endif + +-- VVV Prop "is-ephemeral" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-ephemeral@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #isEphemeral +@ +-} +getWebViewIsEphemeral :: (MonadIO m, IsWebView o) => o -> m Bool +getWebViewIsEphemeral obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-ephemeral" + +{- | +Construct a `GValueConstruct` with valid value for the “@is-ephemeral@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewIsEphemeral :: (IsWebView o) => Bool -> IO (GValueConstruct o) +constructWebViewIsEphemeral val = B.Properties.constructObjectPropertyBool "is-ephemeral" val + +#if ENABLE_OVERLOADING +data WebViewIsEphemeralPropertyInfo +instance AttrInfo WebViewIsEphemeralPropertyInfo where + type AttrAllowedOps WebViewIsEphemeralPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WebViewIsEphemeralPropertyInfo = (~) Bool + type AttrBaseTypeConstraint WebViewIsEphemeralPropertyInfo = IsWebView + type AttrGetType WebViewIsEphemeralPropertyInfo = Bool + type AttrLabel WebViewIsEphemeralPropertyInfo = "is-ephemeral" + type AttrOrigin WebViewIsEphemeralPropertyInfo = WebView + attrGet _ = getWebViewIsEphemeral + attrSet _ = undefined + attrConstruct _ = constructWebViewIsEphemeral + attrClear _ = undefined +#endif + +-- VVV Prop "is-loading" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-loading@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #isLoading +@ +-} +getWebViewIsLoading :: (MonadIO m, IsWebView o) => o -> m Bool +getWebViewIsLoading obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-loading" + +#if ENABLE_OVERLOADING +data WebViewIsLoadingPropertyInfo +instance AttrInfo WebViewIsLoadingPropertyInfo where + type AttrAllowedOps WebViewIsLoadingPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebViewIsLoadingPropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewIsLoadingPropertyInfo = IsWebView + type AttrGetType WebViewIsLoadingPropertyInfo = Bool + type AttrLabel WebViewIsLoadingPropertyInfo = "is-loading" + type AttrOrigin WebViewIsLoadingPropertyInfo = WebView + attrGet _ = getWebViewIsLoading + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "is-playing-audio" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-playing-audio@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #isPlayingAudio +@ +-} +getWebViewIsPlayingAudio :: (MonadIO m, IsWebView o) => o -> m Bool +getWebViewIsPlayingAudio obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-playing-audio" + +#if ENABLE_OVERLOADING +data WebViewIsPlayingAudioPropertyInfo +instance AttrInfo WebViewIsPlayingAudioPropertyInfo where + type AttrAllowedOps WebViewIsPlayingAudioPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint WebViewIsPlayingAudioPropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewIsPlayingAudioPropertyInfo = IsWebView + type AttrGetType WebViewIsPlayingAudioPropertyInfo = Bool + type AttrLabel WebViewIsPlayingAudioPropertyInfo = "is-playing-audio" + type AttrOrigin WebViewIsPlayingAudioPropertyInfo = WebView + attrGet _ = getWebViewIsPlayingAudio + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "related-view" + -- Type: TInterface (Name {namespace = "WebKit2", name = "WebView"}) + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Construct a `GValueConstruct` with valid value for the “@related-view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewRelatedView :: (IsWebView o, IsWebView a) => a -> IO (GValueConstruct o) +constructWebViewRelatedView val = B.Properties.constructObjectPropertyObject "related-view" (Just val) + +#if ENABLE_OVERLOADING +data WebViewRelatedViewPropertyInfo +instance AttrInfo WebViewRelatedViewPropertyInfo where + type AttrAllowedOps WebViewRelatedViewPropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrSetTypeConstraint WebViewRelatedViewPropertyInfo = IsWebView + type AttrBaseTypeConstraint WebViewRelatedViewPropertyInfo = IsWebView + type AttrGetType WebViewRelatedViewPropertyInfo = () + type AttrLabel WebViewRelatedViewPropertyInfo = "related-view" + type AttrOrigin WebViewRelatedViewPropertyInfo = WebView + attrGet _ = undefined + attrSet _ = undefined + attrConstruct _ = constructWebViewRelatedView + attrClear _ = undefined +#endif + +-- VVV Prop "settings" + -- Type: TInterface (Name {namespace = "WebKit2", name = "Settings"}) + -- Flags: [PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Set the value of the “@settings@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' webView [ #settings 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setWebViewSettings :: (MonadIO m, IsWebView o, WebKit2.Settings.IsSettings a) => o -> a -> m () +setWebViewSettings obj val = liftIO $ B.Properties.setObjectPropertyObject obj "settings" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@settings@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewSettings :: (IsWebView o, WebKit2.Settings.IsSettings a) => a -> IO (GValueConstruct o) +constructWebViewSettings val = B.Properties.constructObjectPropertyObject "settings" (Just val) + +#if ENABLE_OVERLOADING +data WebViewSettingsPropertyInfo +instance AttrInfo WebViewSettingsPropertyInfo where + type AttrAllowedOps WebViewSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct] + type AttrSetTypeConstraint WebViewSettingsPropertyInfo = WebKit2.Settings.IsSettings + type AttrBaseTypeConstraint WebViewSettingsPropertyInfo = IsWebView + type AttrGetType WebViewSettingsPropertyInfo = () + type AttrLabel WebViewSettingsPropertyInfo = "settings" + type AttrOrigin WebViewSettingsPropertyInfo = WebView + attrGet _ = undefined + attrSet _ = setWebViewSettings + attrConstruct _ = constructWebViewSettings + attrClear _ = undefined +#endif + +-- VVV Prop "title" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #title +@ +-} +getWebViewTitle :: (MonadIO m, IsWebView o) => o -> m (Maybe T.Text) +getWebViewTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "title" + +#if ENABLE_OVERLOADING +data WebViewTitlePropertyInfo +instance AttrInfo WebViewTitlePropertyInfo where + type AttrAllowedOps WebViewTitlePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebViewTitlePropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewTitlePropertyInfo = IsWebView + type AttrGetType WebViewTitlePropertyInfo = (Maybe T.Text) + type AttrLabel WebViewTitlePropertyInfo = "title" + type AttrOrigin WebViewTitlePropertyInfo = WebView + attrGet _ = getWebViewTitle + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "uri" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@uri@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #uri +@ +-} +getWebViewUri :: (MonadIO m, IsWebView o) => o -> m (Maybe T.Text) +getWebViewUri obj = liftIO $ B.Properties.getObjectPropertyString obj "uri" + +#if ENABLE_OVERLOADING +data WebViewUriPropertyInfo +instance AttrInfo WebViewUriPropertyInfo where + type AttrAllowedOps WebViewUriPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebViewUriPropertyInfo = (~) () + type AttrBaseTypeConstraint WebViewUriPropertyInfo = IsWebView + type AttrGetType WebViewUriPropertyInfo = (Maybe T.Text) + type AttrLabel WebViewUriPropertyInfo = "uri" + type AttrOrigin WebViewUriPropertyInfo = WebView + attrGet _ = getWebViewUri + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "user-content-manager" + -- Type: TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@user-content-manager@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #userContentManager +@ +-} +getWebViewUserContentManager :: (MonadIO m, IsWebView o) => o -> m WebKit2.UserContentManager.UserContentManager +getWebViewUserContentManager obj = liftIO $ checkUnexpectedNothing "getWebViewUserContentManager" $ B.Properties.getObjectPropertyObject obj "user-content-manager" WebKit2.UserContentManager.UserContentManager + +{- | +Construct a `GValueConstruct` with valid value for the “@user-content-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewUserContentManager :: (IsWebView o, WebKit2.UserContentManager.IsUserContentManager a) => a -> IO (GValueConstruct o) +constructWebViewUserContentManager val = B.Properties.constructObjectPropertyObject "user-content-manager" (Just val) + +#if ENABLE_OVERLOADING +data WebViewUserContentManagerPropertyInfo +instance AttrInfo WebViewUserContentManagerPropertyInfo where + type AttrAllowedOps WebViewUserContentManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebViewUserContentManagerPropertyInfo = WebKit2.UserContentManager.IsUserContentManager + type AttrBaseTypeConstraint WebViewUserContentManagerPropertyInfo = IsWebView + type AttrGetType WebViewUserContentManagerPropertyInfo = WebKit2.UserContentManager.UserContentManager + type AttrLabel WebViewUserContentManagerPropertyInfo = "user-content-manager" + type AttrOrigin WebViewUserContentManagerPropertyInfo = WebView + attrGet _ = getWebViewUserContentManager + attrSet _ = undefined + attrConstruct _ = constructWebViewUserContentManager + attrClear _ = undefined +#endif + +-- VVV Prop "web-context" + -- Type: TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@web-context@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #webContext +@ +-} +getWebViewWebContext :: (MonadIO m, IsWebView o) => o -> m (Maybe WebKit2.WebContext.WebContext) +getWebViewWebContext obj = liftIO $ B.Properties.getObjectPropertyObject obj "web-context" WebKit2.WebContext.WebContext + +{- | +Construct a `GValueConstruct` with valid value for the “@web-context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewWebContext :: (IsWebView o, WebKit2.WebContext.IsWebContext a) => a -> IO (GValueConstruct o) +constructWebViewWebContext val = B.Properties.constructObjectPropertyObject "web-context" (Just val) + +#if ENABLE_OVERLOADING +data WebViewWebContextPropertyInfo +instance AttrInfo WebViewWebContextPropertyInfo where + type AttrAllowedOps WebViewWebContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebViewWebContextPropertyInfo = WebKit2.WebContext.IsWebContext + type AttrBaseTypeConstraint WebViewWebContextPropertyInfo = IsWebView + type AttrGetType WebViewWebContextPropertyInfo = (Maybe WebKit2.WebContext.WebContext) + type AttrLabel WebViewWebContextPropertyInfo = "web-context" + type AttrOrigin WebViewWebContextPropertyInfo = WebView + attrGet _ = getWebViewWebContext + attrSet _ = undefined + attrConstruct _ = constructWebViewWebContext + attrClear _ = undefined +#endif + +-- VVV Prop "zoom-level" + -- Type: TBasicType TDouble + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@zoom-level@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' webView #zoomLevel +@ +-} +getWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> m Double +getWebViewZoomLevel obj = liftIO $ B.Properties.getObjectPropertyDouble obj "zoom-level" + +{- | +Set the value of the “@zoom-level@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' webView [ #zoomLevel 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> Double -> m () +setWebViewZoomLevel obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "zoom-level" val + +{- | +Construct a `GValueConstruct` with valid value for the “@zoom-level@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebViewZoomLevel :: (IsWebView o) => Double -> IO (GValueConstruct o) +constructWebViewZoomLevel val = B.Properties.constructObjectPropertyDouble "zoom-level" val + +#if ENABLE_OVERLOADING +data WebViewZoomLevelPropertyInfo +instance AttrInfo WebViewZoomLevelPropertyInfo where + type AttrAllowedOps WebViewZoomLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WebViewZoomLevelPropertyInfo = (~) Double + type AttrBaseTypeConstraint WebViewZoomLevelPropertyInfo = IsWebView + type AttrGetType WebViewZoomLevelPropertyInfo = Double + type AttrLabel WebViewZoomLevelPropertyInfo = "zoom-level" + type AttrOrigin WebViewZoomLevelPropertyInfo = WebView + attrGet _ = getWebViewZoomLevel + attrSet _ = setWebViewZoomLevel + attrConstruct _ = constructWebViewZoomLevel + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebView +type instance O.AttributeList WebView = WebViewAttributeList +type WebViewAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("editable", WebViewEditablePropertyInfo), '("estimatedLoadProgress", WebViewEstimatedLoadProgressPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("favicon", WebViewFaviconPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isControlledByAutomation", WebViewIsControlledByAutomationPropertyInfo), '("isEphemeral", WebViewIsEphemeralPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isLoading", WebViewIsLoadingPropertyInfo), '("isPlayingAudio", WebViewIsPlayingAudioPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedView", WebViewRelatedViewPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("settings", WebViewSettingsPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("title", WebViewTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("uri", WebViewUriPropertyInfo), '("userContentManager", WebViewUserContentManagerPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("webContext", WebViewWebContextPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("zoomLevel", WebViewZoomLevelPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +webViewEditable :: AttrLabelProxy "editable" +webViewEditable = AttrLabelProxy + +webViewEstimatedLoadProgress :: AttrLabelProxy "estimatedLoadProgress" +webViewEstimatedLoadProgress = AttrLabelProxy + +webViewFavicon :: AttrLabelProxy "favicon" +webViewFavicon = AttrLabelProxy + +webViewRelatedView :: AttrLabelProxy "relatedView" +webViewRelatedView = AttrLabelProxy + +webViewSettings :: AttrLabelProxy "settings" +webViewSettings = AttrLabelProxy + +webViewTitle :: AttrLabelProxy "title" +webViewTitle = AttrLabelProxy + +webViewUri :: AttrLabelProxy "uri" +webViewUri = AttrLabelProxy + +webViewUserContentManager :: AttrLabelProxy "userContentManager" +webViewUserContentManager = AttrLabelProxy + +webViewWebContext :: AttrLabelProxy "webContext" +webViewWebContext = AttrLabelProxy + +webViewZoomLevel :: AttrLabelProxy "zoomLevel" +webViewZoomLevel = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data WebViewAuthenticateSignalInfo +instance SignalInfo WebViewAuthenticateSignalInfo where + type HaskellCallbackType WebViewAuthenticateSignalInfo = WebViewAuthenticateCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewAuthenticateCallback cb + cb'' <- mk_WebViewAuthenticateCallback cb' + connectSignalFunPtr obj "authenticate" cb'' connectMode + +data WebViewCloseSignalInfo +instance SignalInfo WebViewCloseSignalInfo where + type HaskellCallbackType WebViewCloseSignalInfo = WebViewCloseCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewCloseCallback cb + cb'' <- mk_WebViewCloseCallback cb' + connectSignalFunPtr obj "close" cb'' connectMode + +data WebViewContextMenuSignalInfo +instance SignalInfo WebViewContextMenuSignalInfo where + type HaskellCallbackType WebViewContextMenuSignalInfo = WebViewContextMenuCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewContextMenuCallback cb + cb'' <- mk_WebViewContextMenuCallback cb' + connectSignalFunPtr obj "context-menu" cb'' connectMode + +data WebViewContextMenuDismissedSignalInfo +instance SignalInfo WebViewContextMenuDismissedSignalInfo where + type HaskellCallbackType WebViewContextMenuDismissedSignalInfo = WebViewContextMenuDismissedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewContextMenuDismissedCallback cb + cb'' <- mk_WebViewContextMenuDismissedCallback cb' + connectSignalFunPtr obj "context-menu-dismissed" cb'' connectMode + +data WebViewCreateSignalInfo +instance SignalInfo WebViewCreateSignalInfo where + type HaskellCallbackType WebViewCreateSignalInfo = WebViewCreateCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewCreateCallback cb + cb'' <- mk_WebViewCreateCallback cb' + connectSignalFunPtr obj "create" cb'' connectMode + +data WebViewDecidePolicySignalInfo +instance SignalInfo WebViewDecidePolicySignalInfo where + type HaskellCallbackType WebViewDecidePolicySignalInfo = WebViewDecidePolicyCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewDecidePolicyCallback cb + cb'' <- mk_WebViewDecidePolicyCallback cb' + connectSignalFunPtr obj "decide-policy" cb'' connectMode + +data WebViewEnterFullscreenSignalInfo +instance SignalInfo WebViewEnterFullscreenSignalInfo where + type HaskellCallbackType WebViewEnterFullscreenSignalInfo = WebViewEnterFullscreenCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewEnterFullscreenCallback cb + cb'' <- mk_WebViewEnterFullscreenCallback cb' + connectSignalFunPtr obj "enter-fullscreen" cb'' connectMode + +data WebViewInsecureContentDetectedSignalInfo +instance SignalInfo WebViewInsecureContentDetectedSignalInfo where + type HaskellCallbackType WebViewInsecureContentDetectedSignalInfo = WebViewInsecureContentDetectedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewInsecureContentDetectedCallback cb + cb'' <- mk_WebViewInsecureContentDetectedCallback cb' + connectSignalFunPtr obj "insecure-content-detected" cb'' connectMode + +data WebViewLeaveFullscreenSignalInfo +instance SignalInfo WebViewLeaveFullscreenSignalInfo where + type HaskellCallbackType WebViewLeaveFullscreenSignalInfo = WebViewLeaveFullscreenCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewLeaveFullscreenCallback cb + cb'' <- mk_WebViewLeaveFullscreenCallback cb' + connectSignalFunPtr obj "leave-fullscreen" cb'' connectMode + +data WebViewLoadChangedSignalInfo +instance SignalInfo WebViewLoadChangedSignalInfo where + type HaskellCallbackType WebViewLoadChangedSignalInfo = WebViewLoadChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewLoadChangedCallback cb + cb'' <- mk_WebViewLoadChangedCallback cb' + connectSignalFunPtr obj "load-changed" cb'' connectMode + +data WebViewLoadFailedSignalInfo +instance SignalInfo WebViewLoadFailedSignalInfo where + type HaskellCallbackType WebViewLoadFailedSignalInfo = WebViewLoadFailedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewLoadFailedCallback cb + cb'' <- mk_WebViewLoadFailedCallback cb' + connectSignalFunPtr obj "load-failed" cb'' connectMode + +data WebViewLoadFailedWithTlsErrorsSignalInfo +instance SignalInfo WebViewLoadFailedWithTlsErrorsSignalInfo where + type HaskellCallbackType WebViewLoadFailedWithTlsErrorsSignalInfo = WebViewLoadFailedWithTlsErrorsCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb + cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb' + connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' connectMode + +data WebViewMouseTargetChangedSignalInfo +instance SignalInfo WebViewMouseTargetChangedSignalInfo where + type HaskellCallbackType WebViewMouseTargetChangedSignalInfo = WebViewMouseTargetChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewMouseTargetChangedCallback cb + cb'' <- mk_WebViewMouseTargetChangedCallback cb' + connectSignalFunPtr obj "mouse-target-changed" cb'' connectMode + +data WebViewPermissionRequestSignalInfo +instance SignalInfo WebViewPermissionRequestSignalInfo where + type HaskellCallbackType WebViewPermissionRequestSignalInfo = WebViewPermissionRequestCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewPermissionRequestCallback cb + cb'' <- mk_WebViewPermissionRequestCallback cb' + connectSignalFunPtr obj "permission-request" cb'' connectMode + +data WebViewPrintSignalInfo +instance SignalInfo WebViewPrintSignalInfo where + type HaskellCallbackType WebViewPrintSignalInfo = WebViewPrintCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewPrintCallback cb + cb'' <- mk_WebViewPrintCallback cb' + connectSignalFunPtr obj "print" cb'' connectMode + +data WebViewReadyToShowSignalInfo +instance SignalInfo WebViewReadyToShowSignalInfo where + type HaskellCallbackType WebViewReadyToShowSignalInfo = WebViewReadyToShowCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewReadyToShowCallback cb + cb'' <- mk_WebViewReadyToShowCallback cb' + connectSignalFunPtr obj "ready-to-show" cb'' connectMode + +data WebViewResourceLoadStartedSignalInfo +instance SignalInfo WebViewResourceLoadStartedSignalInfo where + type HaskellCallbackType WebViewResourceLoadStartedSignalInfo = WebViewResourceLoadStartedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewResourceLoadStartedCallback cb + cb'' <- mk_WebViewResourceLoadStartedCallback cb' + connectSignalFunPtr obj "resource-load-started" cb'' connectMode + +data WebViewRunAsModalSignalInfo +instance SignalInfo WebViewRunAsModalSignalInfo where + type HaskellCallbackType WebViewRunAsModalSignalInfo = WebViewRunAsModalCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewRunAsModalCallback cb + cb'' <- mk_WebViewRunAsModalCallback cb' + connectSignalFunPtr obj "run-as-modal" cb'' connectMode + +data WebViewRunColorChooserSignalInfo +instance SignalInfo WebViewRunColorChooserSignalInfo where + type HaskellCallbackType WebViewRunColorChooserSignalInfo = WebViewRunColorChooserCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewRunColorChooserCallback cb + cb'' <- mk_WebViewRunColorChooserCallback cb' + connectSignalFunPtr obj "run-color-chooser" cb'' connectMode + +data WebViewRunFileChooserSignalInfo +instance SignalInfo WebViewRunFileChooserSignalInfo where + type HaskellCallbackType WebViewRunFileChooserSignalInfo = WebViewRunFileChooserCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewRunFileChooserCallback cb + cb'' <- mk_WebViewRunFileChooserCallback cb' + connectSignalFunPtr obj "run-file-chooser" cb'' connectMode + +data WebViewScriptDialogSignalInfo +instance SignalInfo WebViewScriptDialogSignalInfo where + type HaskellCallbackType WebViewScriptDialogSignalInfo = WebViewScriptDialogCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewScriptDialogCallback cb + cb'' <- mk_WebViewScriptDialogCallback cb' + connectSignalFunPtr obj "script-dialog" cb'' connectMode + +data WebViewShowNotificationSignalInfo +instance SignalInfo WebViewShowNotificationSignalInfo where + type HaskellCallbackType WebViewShowNotificationSignalInfo = WebViewShowNotificationCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewShowNotificationCallback cb + cb'' <- mk_WebViewShowNotificationCallback cb' + connectSignalFunPtr obj "show-notification" cb'' connectMode + +data WebViewShowOptionMenuSignalInfo +instance SignalInfo WebViewShowOptionMenuSignalInfo where + type HaskellCallbackType WebViewShowOptionMenuSignalInfo = WebViewShowOptionMenuCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewShowOptionMenuCallback cb + cb'' <- mk_WebViewShowOptionMenuCallback cb' + connectSignalFunPtr obj "show-option-menu" cb'' connectMode + +data WebViewSubmitFormSignalInfo +instance SignalInfo WebViewSubmitFormSignalInfo where + type HaskellCallbackType WebViewSubmitFormSignalInfo = WebViewSubmitFormCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewSubmitFormCallback cb + cb'' <- mk_WebViewSubmitFormCallback cb' + connectSignalFunPtr obj "submit-form" cb'' connectMode + +data WebViewWebProcessCrashedSignalInfo +instance SignalInfo WebViewWebProcessCrashedSignalInfo where + type HaskellCallbackType WebViewWebProcessCrashedSignalInfo = WebViewWebProcessCrashedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewWebProcessCrashedCallback cb + cb'' <- mk_WebViewWebProcessCrashedCallback cb' + connectSignalFunPtr obj "web-process-crashed" cb'' connectMode + +data WebViewWebProcessTerminatedSignalInfo +instance SignalInfo WebViewWebProcessTerminatedSignalInfo where + type HaskellCallbackType WebViewWebProcessTerminatedSignalInfo = WebViewWebProcessTerminatedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_WebViewWebProcessTerminatedCallback cb + cb'' <- mk_WebViewWebProcessTerminatedCallback cb' + connectSignalFunPtr obj "web-process-terminated" cb'' connectMode + +type instance O.SignalList WebView = WebViewSignalList +type WebViewSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("authenticate", WebViewAuthenticateSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("close", WebViewCloseSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("contextMenu", WebViewContextMenuSignalInfo), '("contextMenuDismissed", WebViewContextMenuDismissedSignalInfo), '("create", WebViewCreateSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("decidePolicy", WebViewDecidePolicySignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterFullscreen", WebViewEnterFullscreenSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insecureContentDetected", WebViewInsecureContentDetectedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveFullscreen", WebViewLeaveFullscreenSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("loadChanged", WebViewLoadChangedSignalInfo), '("loadFailed", WebViewLoadFailedSignalInfo), '("loadFailedWithTlsErrors", WebViewLoadFailedWithTlsErrorsSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("mouseTargetChanged", WebViewMouseTargetChangedSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("permissionRequest", WebViewPermissionRequestSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("print", WebViewPrintSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("readyToShow", WebViewReadyToShowSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("resourceLoadStarted", WebViewResourceLoadStartedSignalInfo), '("runAsModal", WebViewRunAsModalSignalInfo), '("runColorChooser", WebViewRunColorChooserSignalInfo), '("runFileChooser", WebViewRunFileChooserSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scriptDialog", WebViewScriptDialogSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("showNotification", WebViewShowNotificationSignalInfo), '("showOptionMenu", WebViewShowOptionMenuSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("submitForm", WebViewSubmitFormSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("webProcessCrashed", WebViewWebProcessCrashedSignalInfo), '("webProcessTerminated", WebViewWebProcessTerminatedSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WebView::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_new" webkit_web_view_new :: + IO (Ptr WebView) + +{- | +Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the default 'GI.WebKit2.Objects.WebContext.WebContext' and +no 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with it. +See also 'GI.WebKit2.Objects.WebView.webViewNewWithContext', +'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager', and +'GI.WebKit2.Objects.WebView.webViewNewWithSettings'. +-} +webViewNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m WebView + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -} +webViewNew = liftIO $ do + result <- webkit_web_view_new + checkUnexpectedReturnNULL "webViewNew" result + result' <- (newObject WebView) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebView::new_with_context +-- method type : Constructor +-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext to be used by the #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_new_with_context" webkit_web_view_new_with_context :: + Ptr WebKit2.WebContext.WebContext -> -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"}) + IO (Ptr WebView) + +{- | +Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.WebContext.WebContext' and +no 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with it. +See also 'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager' and +'GI.WebKit2.Objects.WebView.webViewNewWithSettings'. +-} +webViewNewWithContext :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.WebContext.IsWebContext a) => + a + {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' to be used by the 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebView + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -} +webViewNewWithContext context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- webkit_web_view_new_with_context context' + checkUnexpectedReturnNULL "webViewNewWithContext" result + result' <- (newObject WebView) result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebView::new_with_related_view +-- method type : Constructor +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the related #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_new_with_related_view" webkit_web_view_new_with_related_view :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebView) + +{- | +Creates a new 'GI.WebKit2.Objects.WebView.WebView' sharing the same web process with /@webView@/. +This method doesn\'t have any effect when 'GI.WebKit2.Enums.ProcessModelSharedSecondaryProcess' +process model is used, because a single web process is shared for all the web views in the +same 'GI.WebKit2.Objects.WebContext.WebContext'. When using 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses' process model, +this method should always be used when creating the 'GI.WebKit2.Objects.WebView.WebView' in the 'GI.WebKit2.Objects.WebView.WebView'::@/create/@ signal. +You can also use this method to implement other process models based on 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses', +like for example, sharing the same web process for all the views in the same security domain. + +The newly created 'GI.WebKit2.Objects.WebView.WebView' will also have the same 'GI.WebKit2.Objects.UserContentManager.UserContentManager' +and 'GI.WebKit2.Objects.Settings.Settings' as /@webView@/. + +/Since: 2.4/ +-} +webViewNewWithRelatedView :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: the related 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebView + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -} +webViewNewWithRelatedView webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_new_with_related_view webView' + checkUnexpectedReturnNULL "webViewNewWithRelatedView" result + result' <- (wrapObject WebView) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebView::new_with_settings +-- method type : Constructor +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_new_with_settings" webkit_web_view_new_with_settings :: + Ptr WebKit2.Settings.Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO (Ptr WebView) + +{- | +Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.Settings.Settings'. +See also 'GI.WebKit2.Objects.WebView.webViewNewWithContext', and +'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager'. + +/Since: 2.6/ +-} +webViewNewWithSettings :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.Settings.IsSettings a) => + a + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m WebView + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -} +webViewNewWithSettings settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- webkit_web_view_new_with_settings settings' + checkUnexpectedReturnNULL "webViewNewWithSettings" result + result' <- (newObject WebView) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebView::new_with_user_content_manager +-- method type : Constructor +-- Args : [Arg {argCName = "user_content_manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_new_with_user_content_manager" webkit_web_view_new_with_user_content_manager :: + Ptr WebKit2.UserContentManager.UserContentManager -> -- user_content_manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}) + IO (Ptr WebView) + +{- | +Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. +The content loaded in the view may be affected by the content injected +in the view by the user content manager. + +/Since: 2.6/ +-} +webViewNewWithUserContentManager :: + (B.CallStack.HasCallStack, MonadIO m, WebKit2.UserContentManager.IsUserContentManager a) => + a + {- ^ /@userContentManager@/: a 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. -} + -> m WebView + {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -} +webViewNewWithUserContentManager userContentManager = liftIO $ do + userContentManager' <- unsafeManagedPtrCastPtr userContentManager + result <- webkit_web_view_new_with_user_content_manager userContentManager' + checkUnexpectedReturnNULL "webViewNewWithUserContentManager" result + result' <- (newObject WebView) result + touchManagedPtr userContentManager + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebView::can_execute_editing_command +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command to check", 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 = 4, 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_view_can_execute_editing_command" webkit_web_view_can_execute_editing_command :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- command : TBasicType TUTF8 + 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 check if it is possible to execute the given editing command. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommandFinish' to get the result of the operation. +-} +webViewCanExecuteEditingCommand :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@command@/: the command to check -} + -> 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 () +webViewCanExecuteEditingCommand webView command cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + command' <- textToCString command + 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_view_can_execute_editing_command webView' command' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + freeMem command' + return () + +#if ENABLE_OVERLOADING +data WebViewCanExecuteEditingCommandMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewCanExecuteEditingCommandMethodInfo a signature where + overloadedMethod _ = webViewCanExecuteEditingCommand + +#endif + +-- method WebView::can_execute_editing_command_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_can_execute_editing_command_finish" webkit_web_view_can_execute_editing_command_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'. +-} +webViewCanExecuteEditingCommandFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewCanExecuteEditingCommandFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_web_view_can_execute_editing_command_finish webView' result_' + touchManagedPtr webView + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewCanExecuteEditingCommandFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewCanExecuteEditingCommandFinishMethodInfo a signature where + overloadedMethod _ = webViewCanExecuteEditingCommandFinish + +#endif + +-- method WebView::can_go_back +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_can_go_back" webkit_web_view_can_go_back :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Determines whether /@webView@/ has a previous history item. +-} +webViewCanGoBack :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if able to move back or 'False' otherwise. -} +webViewCanGoBack webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_can_go_back webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewCanGoBackMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanGoBackMethodInfo a signature where + overloadedMethod _ = webViewCanGoBack + +#endif + +-- method WebView::can_go_forward +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_can_go_forward" webkit_web_view_can_go_forward :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Determines whether /@webView@/ has a next history item. +-} +webViewCanGoForward :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if able to move forward or 'False' otherwise. -} +webViewCanGoForward webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_can_go_forward webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewCanGoForwardMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanGoForwardMethodInfo a signature where + overloadedMethod _ = webViewCanGoForward + +#endif + +-- method WebView::can_show_mime_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 "a MIME type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_can_show_mime_type" webkit_web_view_can_show_mime_type :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- mime_type : TBasicType TUTF8 + IO CInt + +{- | +Whether or not a MIME type can be displayed in /@webView@/. +-} +webViewCanShowMimeType :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@mimeType@/: a MIME type -} + -> m Bool + {- ^ __Returns:__ 'True' if the MIME type /@mimeType@/ can be displayed or 'False' otherwise -} +webViewCanShowMimeType webView mimeType = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + mimeType' <- textToCString mimeType + result <- webkit_web_view_can_show_mime_type webView' mimeType' + let result' = (/= 0) result + touchManagedPtr webView + freeMem mimeType' + return result' + +#if ENABLE_OVERLOADING +data WebViewCanShowMimeTypeMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanShowMimeTypeMethodInfo a signature where + overloadedMethod _ = webViewCanShowMimeType + +#endif + +-- method WebView::download_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 to download", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Download"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_download_uri" webkit_web_view_download_uri :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- uri : TBasicType TUTF8 + IO (Ptr WebKit2.Download.Download) + +{- | +Requests downloading of the specified URI string for /@webView@/. +-} +webViewDownloadUri :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@uri@/: the URI to download -} + -> m WebKit2.Download.Download + {- ^ __Returns:__ a new 'GI.WebKit2.Objects.Download.Download' representing + the download operation. -} +webViewDownloadUri webView uri = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + uri' <- textToCString uri + result <- webkit_web_view_download_uri webView' uri' + checkUnexpectedReturnNULL "webViewDownloadUri" result + result' <- (wrapObject WebKit2.Download.Download) result + touchManagedPtr webView + freeMem uri' + return result' + +#if ENABLE_OVERLOADING +data WebViewDownloadUriMethodInfo +instance (signature ~ (T.Text -> m WebKit2.Download.Download), MonadIO m, IsWebView a) => O.MethodInfo WebViewDownloadUriMethodInfo a signature where + overloadedMethod _ = webViewDownloadUri + +#endif + +-- method WebView::execute_editing_command +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command to execute", 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_view_execute_editing_command" webkit_web_view_execute_editing_command :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- command : TBasicType TUTF8 + IO () + +{- | +Request to execute the given /@command@/ for /@webView@/. You can use +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand' to check whether +it\'s possible to execute the command. +-} +webViewExecuteEditingCommand :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@command@/: the command to execute -} + -> m () +webViewExecuteEditingCommand webView command = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + command' <- textToCString command + webkit_web_view_execute_editing_command webView' command' + touchManagedPtr webView + freeMem command' + return () + +#if ENABLE_OVERLOADING +data WebViewExecuteEditingCommandMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewExecuteEditingCommandMethodInfo a signature where + overloadedMethod _ = webViewExecuteEditingCommand + +#endif + +-- method WebView::execute_editing_command_with_argument +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command to execute", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "argument", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command argument", 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_view_execute_editing_command_with_argument" webkit_web_view_execute_editing_command_with_argument :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- command : TBasicType TUTF8 + CString -> -- argument : TBasicType TUTF8 + IO () + +{- | +Request to execute the given /@command@/ with /@argument@/ for /@webView@/. You can use +'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand' to check whether +it\'s possible to execute the command. + +/Since: 2.10/ +-} +webViewExecuteEditingCommandWithArgument :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@command@/: the command to execute -} + -> T.Text + {- ^ /@argument@/: the command argument -} + -> m () +webViewExecuteEditingCommandWithArgument webView command argument = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + command' <- textToCString command + argument' <- textToCString argument + webkit_web_view_execute_editing_command_with_argument webView' command' argument' + touchManagedPtr webView + freeMem command' + freeMem argument' + return () + +#if ENABLE_OVERLOADING +data WebViewExecuteEditingCommandWithArgumentMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewExecuteEditingCommandWithArgumentMethodInfo a signature where + overloadedMethod _ = webViewExecuteEditingCommandWithArgument + +#endif + +-- method WebView::get_back_forward_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_back_forward_list" webkit_web_view_get_back_forward_list :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.BackForwardList.BackForwardList) + +{- | +Obtains the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' associated with the given 'GI.WebKit2.Objects.WebView.WebView'. The +'GI.WebKit2.Objects.BackForwardList.BackForwardList' is owned by the 'GI.WebKit2.Objects.WebView.WebView'. +-} +webViewGetBackForwardList :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.BackForwardList.BackForwardList + {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -} +webViewGetBackForwardList webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_back_forward_list webView' + checkUnexpectedReturnNULL "webViewGetBackForwardList" result + result' <- (newObject WebKit2.BackForwardList.BackForwardList) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetBackForwardListMethodInfo +instance (signature ~ (m WebKit2.BackForwardList.BackForwardList), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetBackForwardListMethodInfo a signature where + overloadedMethod _ = webViewGetBackForwardList + +#endif + +-- method WebView::get_background_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA to fill in with the background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_background_color" webkit_web_view_get_background_color :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gdk.RGBA.RGBA -> -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Gets the color that is used to draw the /@webView@/ background before +the actual contents are rendered. +For more information see also 'GI.WebKit2.Objects.WebView.webViewSetBackgroundColor' + +/Since: 2.8/ +-} +webViewGetBackgroundColor :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Gdk.RGBA.RGBA) +webViewGetBackgroundColor webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + rgba <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA) + webkit_web_view_get_background_color webView' rgba + rgba' <- (wrapBoxed Gdk.RGBA.RGBA) rgba + touchManagedPtr webView + return rgba' + +#if ENABLE_OVERLOADING +data WebViewGetBackgroundColorMethodInfo +instance (signature ~ (m (Gdk.RGBA.RGBA)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetBackgroundColorMethodInfo a signature where + overloadedMethod _ = webViewGetBackgroundColor + +#endif + +-- method WebView::get_context +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_context" webkit_web_view_get_context :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WebContext.WebContext) + +{- | +Gets the web context of /@webView@/. +-} +webViewGetContext :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.WebContext.WebContext + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebContext.WebContext' of the view -} +webViewGetContext webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_context webView' + checkUnexpectedReturnNULL "webViewGetContext" result + result' <- (newObject WebKit2.WebContext.WebContext) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetContextMethodInfo +instance (signature ~ (m WebKit2.WebContext.WebContext), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetContextMethodInfo a signature where + overloadedMethod _ = webViewGetContext + +#endif + +-- method WebView::get_custom_charset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_get_custom_charset" webkit_web_view_get_custom_charset :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CString + +{- | +Returns the current custom character encoding name of /@webView@/. +-} +webViewGetCustomCharset :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the current custom character encoding name or 'Nothing' if no + custom character encoding has been set. -} +webViewGetCustomCharset webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_custom_charset webView' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr webView + return maybeResult + +#if ENABLE_OVERLOADING +data WebViewGetCustomCharsetMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetCustomCharsetMethodInfo a signature where + overloadedMethod _ = webViewGetCustomCharset + +#endif + +-- method WebView::get_editor_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "EditorState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_editor_state" webkit_web_view_get_editor_state :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.EditorState.EditorState) + +{- | +Gets the web editor state of /@webView@/. + +/Since: 2.10/ +-} +webViewGetEditorState :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.EditorState.EditorState + {- ^ __Returns:__ the 'GI.WebKit2.Objects.EditorState.EditorState' of the view -} +webViewGetEditorState webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_editor_state webView' + checkUnexpectedReturnNULL "webViewGetEditorState" result + result' <- (newObject WebKit2.EditorState.EditorState) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetEditorStateMethodInfo +instance (signature ~ (m WebKit2.EditorState.EditorState), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetEditorStateMethodInfo a signature where + overloadedMethod _ = webViewGetEditorState + +#endif + +-- method WebView::get_estimated_load_progress +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_estimated_load_progress" webkit_web_view_get_estimated_load_progress :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CDouble + +{- | +Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/estimated-load-progress/@ property. +You can monitor the estimated progress of a load operation by +connecting to the notify::estimated-load-progress signal of /@webView@/. +-} +webViewGetEstimatedLoadProgress :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Double + {- ^ __Returns:__ an estimate of the of the percent complete for a document + load as a range from 0.0 to 1.0. -} +webViewGetEstimatedLoadProgress webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_estimated_load_progress webView' + let result' = realToFrac result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetEstimatedLoadProgressMethodInfo +instance (signature ~ (m Double), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetEstimatedLoadProgressMethodInfo a signature where + overloadedMethod _ = webViewGetEstimatedLoadProgress + +#endif + +-- method WebView::get_favicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_favicon" webkit_web_view_get_favicon :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr Cairo.Surface.Surface) + +{- | +Returns favicon currently associated to /@webView@/, if any. You can +connect to notify::favicon signal of /@webView@/ to be notified when +the favicon is available. +-} +webViewGetFavicon :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Maybe Cairo.Surface.Surface) + {- ^ __Returns:__ a pointer to a 'GI.Cairo.Structs.Surface.Surface' with the + favicon or 'Nothing' if there\'s no icon associated with /@webView@/. -} +webViewGetFavicon webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_favicon webView' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Cairo.Surface.Surface) result' + return result'' + touchManagedPtr webView + return maybeResult + +#if ENABLE_OVERLOADING +data WebViewGetFaviconMethodInfo +instance (signature ~ (m (Maybe Cairo.Surface.Surface)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetFaviconMethodInfo a signature where + overloadedMethod _ = webViewGetFavicon + +#endif + +-- method WebView::get_find_controller +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "FindController"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_find_controller" webkit_web_view_get_find_controller :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.FindController.FindController) + +{- | +Gets the 'GI.WebKit2.Objects.FindController.FindController' that will allow the caller to query +the 'GI.WebKit2.Objects.WebView.WebView' for the text to look for. +-} +webViewGetFindController :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: the 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.FindController.FindController + {- ^ __Returns:__ the 'GI.WebKit2.Objects.FindController.FindController' associated to +this particular 'GI.WebKit2.Objects.WebView.WebView'. -} +webViewGetFindController webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_find_controller webView' + checkUnexpectedReturnNULL "webViewGetFindController" result + result' <- (newObject WebKit2.FindController.FindController) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetFindControllerMethodInfo +instance (signature ~ (m WebKit2.FindController.FindController), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetFindControllerMethodInfo a signature where + overloadedMethod _ = webViewGetFindController + +#endif + +-- method WebView::get_inspector +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebInspector"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_inspector" webkit_web_view_get_inspector :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WebInspector.WebInspector) + +{- | +Get the 'GI.WebKit2.Objects.WebInspector.WebInspector' associated to /@webView@/ +-} +webViewGetInspector :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.WebInspector.WebInspector + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebInspector.WebInspector' of /@webView@/ -} +webViewGetInspector webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_inspector webView' + checkUnexpectedReturnNULL "webViewGetInspector" result + result' <- (newObject WebKit2.WebInspector.WebInspector) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetInspectorMethodInfo +instance (signature ~ (m WebKit2.WebInspector.WebInspector), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetInspectorMethodInfo a signature where + overloadedMethod _ = webViewGetInspector + +#endif + +-- method WebView::get_main_resource +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebResource"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_main_resource" webkit_web_view_get_main_resource :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WebResource.WebResource) + +{- | +Return the main resource of /@webView@/. +-} +webViewGetMainResource :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Maybe WebKit2.WebResource.WebResource) + {- ^ __Returns:__ the main 'GI.WebKit2.Objects.WebResource.WebResource' of the view + or 'Nothing' if nothing has been loaded. -} +webViewGetMainResource webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_main_resource webView' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject WebKit2.WebResource.WebResource) result' + return result'' + touchManagedPtr webView + return maybeResult + +#if ENABLE_OVERLOADING +data WebViewGetMainResourceMethodInfo +instance (signature ~ (m (Maybe WebKit2.WebResource.WebResource)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetMainResourceMethodInfo a signature where + overloadedMethod _ = webViewGetMainResource + +#endif + +-- method WebView::get_page_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_page_id" webkit_web_view_get_page_id :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO Word64 + +{- | +Get the identifier of the @/WebKitWebPage/@ corresponding to +the 'GI.WebKit2.Objects.WebView.WebView' +-} +webViewGetPageId :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Word64 + {- ^ __Returns:__ the page ID of /@webView@/. -} +webViewGetPageId webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_page_id webView' + touchManagedPtr webView + return result + +#if ENABLE_OVERLOADING +data WebViewGetPageIdMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetPageIdMethodInfo a signature where + overloadedMethod _ = webViewGetPageId + +#endif + +-- method WebView::get_session_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_session_state" webkit_web_view_get_session_state :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WebViewSessionState.WebViewSessionState) + +{- | +Gets the current session state of /@webView@/ + +/Since: 2.12/ +-} +webViewGetSessionState :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.WebViewSessionState.WebViewSessionState + {- ^ __Returns:__ a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} +webViewGetSessionState webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_session_state webView' + checkUnexpectedReturnNULL "webViewGetSessionState" result + result' <- (wrapBoxed WebKit2.WebViewSessionState.WebViewSessionState) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetSessionStateMethodInfo +instance (signature ~ (m WebKit2.WebViewSessionState.WebViewSessionState), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetSessionStateMethodInfo a signature where + overloadedMethod _ = webViewGetSessionState + +#endif + +-- method WebView::get_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Settings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_settings" webkit_web_view_get_settings :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.Settings.Settings) + +{- | +Gets the 'GI.WebKit2.Objects.Settings.Settings' currently applied to /@webView@/. +If no other 'GI.WebKit2.Objects.Settings.Settings' have been explicitly applied to +/@webView@/ with 'GI.WebKit2.Objects.WebView.webViewSetSettings', the default +'GI.WebKit2.Objects.Settings.Settings' will be returned. This method always returns +a valid 'GI.WebKit2.Objects.Settings.Settings' object. +To modify any of the /@webView@/ settings, you can either create +a new 'GI.WebKit2.Objects.Settings.Settings' object with 'GI.WebKit2.Objects.Settings.settingsNew', setting +the desired preferences, and then replace the existing /@webView@/ +settings with 'GI.WebKit2.Objects.WebView.webViewSetSettings' or get the existing +/@webView@/ settings and update it directly. 'GI.WebKit2.Objects.Settings.Settings' objects +can be shared by multiple 'GI.WebKit2.Objects.WebView.WebView'\s, so modifying +the settings of a 'GI.WebKit2.Objects.WebView.WebView' would affect other +'GI.WebKit2.Objects.WebView.WebView'\s using the same 'GI.WebKit2.Objects.Settings.Settings'. +-} +webViewGetSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.Settings.Settings + {- ^ __Returns:__ the 'GI.WebKit2.Objects.Settings.Settings' attached to /@webView@/ -} +webViewGetSettings webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_settings webView' + checkUnexpectedReturnNULL "webViewGetSettings" result + result' <- (newObject WebKit2.Settings.Settings) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetSettingsMethodInfo +instance (signature ~ (m WebKit2.Settings.Settings), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetSettingsMethodInfo a signature where + overloadedMethod _ = webViewGetSettings + +#endif + +-- method WebView::get_snapshot +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "WebKit2", name = "SnapshotRegion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSnapshotRegion for this snapshot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "WebKit2", name = "SnapshotOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#WebKitSnapshotOptions for the snapshot", 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", 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", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", 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_view_get_snapshot" webkit_web_view_get_snapshot :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CUInt -> -- region : TInterface (Name {namespace = "WebKit2", name = "SnapshotRegion"}) + CUInt -> -- options : TInterface (Name {namespace = "WebKit2", name = "SnapshotOptions"}) + 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 retrieves a snapshot of /@webView@/ for /@region@/. +/@options@/ specifies how the snapshot should be rendered. + +When the operation is finished, /@callback@/ will be called. You must +call 'GI.WebKit2.Objects.WebView.webViewGetSnapshotFinish' to get the result of the +operation. +-} +webViewGetSnapshot :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> WebKit2.Enums.SnapshotRegion + {- ^ /@region@/: the 'GI.WebKit2.Enums.SnapshotRegion' for this snapshot -} + -> [WebKit2.Flags.SnapshotOptions] + {- ^ /@options@/: 'GI.WebKit2.Flags.SnapshotOptions' for the snapshot -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -} + -> m () +webViewGetSnapshot webView region options cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + let region' = (fromIntegral . fromEnum) region + let options' = gflagsToWord options + 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_view_get_snapshot webView' region' options' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebViewGetSnapshotMethodInfo +instance (signature ~ (WebKit2.Enums.SnapshotRegion -> [WebKit2.Flags.SnapshotOptions] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewGetSnapshotMethodInfo a signature where + overloadedMethod _ = webViewGetSnapshot + +#endif + +-- method WebView::get_snapshot_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_get_snapshot_finish" webkit_web_view_get_snapshot_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Cairo.Surface.Surface) + +{- | +Finishes an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewGetSnapshot'. +-} +webViewGetSnapshotFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m Cairo.Surface.Surface + {- ^ __Returns:__ a 'GI.Cairo.Structs.Surface.Surface' with the retrieved snapshot or 'Nothing' in error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewGetSnapshotFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_view_get_snapshot_finish webView' result_' + checkUnexpectedReturnNULL "webViewGetSnapshotFinish" result + result' <- (wrapBoxed Cairo.Surface.Surface) result + touchManagedPtr webView + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewGetSnapshotFinishMethodInfo +instance (signature ~ (b -> m Cairo.Surface.Surface), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewGetSnapshotFinishMethodInfo a signature where + overloadedMethod _ = webViewGetSnapshotFinish + +#endif + +-- method WebView::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_get_title" webkit_web_view_get_title :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CString + +{- | +Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/title/@ property. +You can connect to notify::title signal of /@webView@/ to +be notified when the title has been received. +-} +webViewGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ The main frame document title of /@webView@/. -} +webViewGetTitle webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_title webView' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr webView + return maybeResult + +#if ENABLE_OVERLOADING +data WebViewGetTitleMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetTitleMethodInfo a signature where + overloadedMethod _ = webViewGetTitle + +#endif + +-- method WebView::get_tls_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "errors", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GTlsCertificateFlags the verification status of @certificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_tls_info" webkit_web_view_get_tls_info :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr (Ptr Gio.TlsCertificate.TlsCertificate) -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"}) + Ptr CUInt -> -- errors : TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}) + IO CInt + +{- | +Retrieves the 'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with the main resource of /@webView@/, +and the 'GI.Gio.Flags.TlsCertificateFlags' showing what problems, if any, have been found +with that certificate. +If the connection is not HTTPS, this function returns 'False'. +This function should be called after a response has been received from the +server, so you can connect to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ and call this function +when it\'s emitted with 'GI.WebKit2.Enums.LoadEventCommitted' event. + +Note that this function provides no information about the security of the web +page if the current 'GI.WebKit2.Enums.TLSErrorsPolicy' is /@wEBKITTLSERRORSPOLICYIGNORE@/, +as subresources of the page may be controlled by an attacker. This function +may safely be used to determine the security status of the current page only +if the current 'GI.WebKit2.Enums.TLSErrorsPolicy' is /@wEBKITTLSERRORSPOLICYFAIL@/, in +which case subresources that fail certificate verification will be blocked. +-} +webViewGetTlsInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m ((Bool, Gio.TlsCertificate.TlsCertificate, [Gio.Flags.TlsCertificateFlags])) + {- ^ __Returns:__ 'True' if the /@webView@/ connection uses HTTPS and a response has been received + from the server, or 'False' otherwise. -} +webViewGetTlsInfo webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + certificate <- allocMem :: IO (Ptr (Ptr Gio.TlsCertificate.TlsCertificate)) + errors <- allocMem :: IO (Ptr CUInt) + result <- webkit_web_view_get_tls_info webView' certificate errors + let result' = (/= 0) result + certificate' <- peek certificate + certificate'' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate' + errors' <- peek errors + let errors'' = wordToGFlags errors' + touchManagedPtr webView + freeMem certificate + freeMem errors + return (result', certificate'', errors'') + +#if ENABLE_OVERLOADING +data WebViewGetTlsInfoMethodInfo +instance (signature ~ (m ((Bool, Gio.TlsCertificate.TlsCertificate, [Gio.Flags.TlsCertificateFlags]))), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetTlsInfoMethodInfo a signature where + overloadedMethod _ = webViewGetTlsInfo + +#endif + +-- method WebView::get_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_get_uri" webkit_web_view_get_uri :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CString + +{- | +Returns the current active URI of /@webView@/. The active URI might change during +a load operation: + +\ +\\ + When nothing has been loaded yet on /@webView@/ the active URI is 'Nothing'. +\<\/para>\<\/listitem> +\\ + When a new load operation starts the active URI is the requested URI: + \ + \\ + If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadUri', + the requested URI is the given one. + \<\/para>\<\/listitem> + \\ + If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadHtml', + the requested URI is \"about:blank\". + \<\/para>\<\/listitem> + \\ + If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadAlternateHtml', + the requested URI is content URI provided. + \<\/para>\<\/listitem> + \\ + If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewGoBack' or + 'GI.WebKit2.Objects.WebView.webViewGoForward', the requested URI is the original URI + of the previous\/next item in the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' of /@webView@/. + \<\/para>\<\/listitem> + \\ + If the load operation was started by + 'GI.WebKit2.Objects.WebView.webViewGoToBackForwardListItem', the requested URI + is the opriginal URI of the given 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'. + \<\/para>\<\/listitem> + \<\/itemizedlist> +\<\/para>\<\/listitem> +\\ + If there is a server redirection during the load operation, + the active URI is the redirected URI. When the signal + 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with 'GI.WebKit2.Enums.LoadEventRedirected' + event, the active URI is already updated to the redirected URI. +\<\/para>\<\/listitem> +\\ + When the signal 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted + with 'GI.WebKit2.Enums.LoadEventCommitted' event, the active URI is the final + one and it will not change unless a new load operation is started + or a navigation action within the same page is performed. +\<\/para>\<\/listitem> +\<\/orderedlist> + +You can monitor the active URI by connecting to the notify::uri +signal of /@webView@/. +-} +webViewGetUri :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the current active URI of /@webView@/ or 'Nothing' + if nothing has been loaded yet. -} +webViewGetUri webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_uri webView' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr webView + return maybeResult + +#if ENABLE_OVERLOADING +data WebViewGetUriMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetUriMethodInfo a signature where + overloadedMethod _ = webViewGetUri + +#endif + +-- method WebView::get_user_content_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_user_content_manager" webkit_web_view_get_user_content_manager :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.UserContentManager.UserContentManager) + +{- | +Gets the user content manager associated to /@webView@/. + +/Since: 2.6/ +-} +webViewGetUserContentManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.UserContentManager.UserContentManager + {- ^ __Returns:__ the 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with the view -} +webViewGetUserContentManager webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_user_content_manager webView' + checkUnexpectedReturnNULL "webViewGetUserContentManager" result + result' <- (newObject WebKit2.UserContentManager.UserContentManager) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetUserContentManagerMethodInfo +instance (signature ~ (m WebKit2.UserContentManager.UserContentManager), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetUserContentManagerMethodInfo a signature where + overloadedMethod _ = webViewGetUserContentManager + +#endif + +-- method WebView::get_website_data_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_website_data_manager" webkit_web_view_get_website_data_manager :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WebsiteDataManager.WebsiteDataManager) + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' associated to /@webView@/. If /@webView@/ is not ephemeral, +the returned 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' will be the same as the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' +of /@webView@/\'s 'GI.WebKit2.Objects.WebContext.WebContext'. + +/Since: 2.16/ +-} +webViewGetWebsiteDataManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.WebsiteDataManager.WebsiteDataManager + {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} +webViewGetWebsiteDataManager webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_website_data_manager webView' + checkUnexpectedReturnNULL "webViewGetWebsiteDataManager" result + result' <- (newObject WebKit2.WebsiteDataManager.WebsiteDataManager) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetWebsiteDataManagerMethodInfo +instance (signature ~ (m WebKit2.WebsiteDataManager.WebsiteDataManager), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetWebsiteDataManagerMethodInfo a signature where + overloadedMethod _ = webViewGetWebsiteDataManager + +#endif + +-- method WebView::get_window_properties +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WindowProperties"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_window_properties" webkit_web_view_get_window_properties :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO (Ptr WebKit2.WindowProperties.WindowProperties) + +{- | +Get the 'GI.WebKit2.Objects.WindowProperties.WindowProperties' object containing the properties +that the window containing /@webView@/ should have. +-} +webViewGetWindowProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m WebKit2.WindowProperties.WindowProperties + {- ^ __Returns:__ the 'GI.WebKit2.Objects.WindowProperties.WindowProperties' of /@webView@/ -} +webViewGetWindowProperties webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_window_properties webView' + checkUnexpectedReturnNULL "webViewGetWindowProperties" result + result' <- (newObject WebKit2.WindowProperties.WindowProperties) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetWindowPropertiesMethodInfo +instance (signature ~ (m WebKit2.WindowProperties.WindowProperties), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetWindowPropertiesMethodInfo a signature where + overloadedMethod _ = webViewGetWindowProperties + +#endif + +-- method WebView::get_zoom_level +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_get_zoom_level" webkit_web_view_get_zoom_level :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CDouble + +{- | +Get the zoom level of /@webView@/, i.e. the factor by which the +view contents are scaled with respect to their original size. +-} +webViewGetZoomLevel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Double + {- ^ __Returns:__ the current zoom level of /@webView@/ -} +webViewGetZoomLevel webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_get_zoom_level webView' + let result' = realToFrac result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewGetZoomLevelMethodInfo +instance (signature ~ (m Double), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetZoomLevelMethodInfo a signature where + overloadedMethod _ = webViewGetZoomLevel + +#endif + +-- method WebView::go_back +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_go_back" webkit_web_view_go_back :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Loads the previous history item. +You can monitor the load operation by connecting to +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewGoBack :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewGoBack webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_go_back webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewGoBackMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewGoBackMethodInfo a signature where + overloadedMethod _ = webViewGoBack + +#endif + +-- method WebView::go_forward +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_go_forward" webkit_web_view_go_forward :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Loads the next history item. +You can monitor the load operation by connecting to +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewGoForward :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewGoForward webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_go_forward webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewGoForwardMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewGoForwardMethodInfo a signature where + overloadedMethod _ = webViewGoForward + +#endif + +-- method WebView::go_to_back_forward_list_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list_item", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardListItem", 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_view_go_to_back_forward_list_item" webkit_web_view_go_to_back_forward_list_item :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr WebKit2.BackForwardListItem.BackForwardListItem -> -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}) + IO () + +{- | +Loads the specific history item /@listItem@/. +You can monitor the load operation by connecting to +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewGoToBackForwardListItem :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.BackForwardListItem.IsBackForwardListItem b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@listItem@/: a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' -} + -> m () +webViewGoToBackForwardListItem webView listItem = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + listItem' <- unsafeManagedPtrCastPtr listItem + webkit_web_view_go_to_back_forward_list_item webView' listItem' + touchManagedPtr webView + touchManagedPtr listItem + return () + +#if ENABLE_OVERLOADING +data WebViewGoToBackForwardListItemMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.BackForwardListItem.IsBackForwardListItem b) => O.MethodInfo WebViewGoToBackForwardListItemMethodInfo a signature where + overloadedMethod _ = webViewGoToBackForwardListItem + +#endif + +-- method WebView::is_controlled_by_automation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_is_controlled_by_automation" webkit_web_view_is_controlled_by_automation :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Get whether a 'GI.WebKit2.Objects.WebView.WebView' was created with 'GI.WebKit2.Objects.WebView.WebView':@/is-controlled-by-automation/@ +property enabled. Only 'GI.WebKit2.Objects.WebView.WebView'\s controlled by automation can be used in an +automation session. + +/Since: 2.18/ +-} +webViewIsControlledByAutomation :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@webView@/ is controlled by automation, or 'False' otherwise. -} +webViewIsControlledByAutomation webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_is_controlled_by_automation webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewIsControlledByAutomationMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsControlledByAutomationMethodInfo a signature where + overloadedMethod _ = webViewIsControlledByAutomation + +#endif + +-- method WebView::is_editable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_is_editable" webkit_web_view_is_editable :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +webViewIsEditable :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + -> m Bool +webViewIsEditable webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_is_editable webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewIsEditableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsEditableMethodInfo a signature where + overloadedMethod _ = webViewIsEditable + +#endif + +-- method WebView::is_ephemeral +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_is_ephemeral" webkit_web_view_is_ephemeral :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Get whether a 'GI.WebKit2.Objects.WebView.WebView' is ephemeral. To create an ephemeral 'GI.WebKit2.Objects.WebView.WebView' you need to +use @/g_object_new()/@ and pass is-ephemeral property with 'True' value. See +'GI.WebKit2.Objects.WebView.WebView':@/is-ephemeral/@ for more details. +If /@webView@/ was created with a ephemeral 'GI.WebKit2.Objects.WebView.WebView':@/related-view/@ or an +ephemeral 'GI.WebKit2.Objects.WebView.WebView':@/web-context/@ it will also be ephemeral. + +/Since: 2.16/ +-} +webViewIsEphemeral :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@webView@/ is ephemeral or 'False' otherwise. -} +webViewIsEphemeral webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_is_ephemeral webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewIsEphemeralMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsEphemeralMethodInfo a signature where + overloadedMethod _ = webViewIsEphemeral + +#endif + +-- method WebView::is_loading +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_is_loading" webkit_web_view_is_loading :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/is-loading/@ property. +You can monitor when a 'GI.WebKit2.Objects.WebView.WebView' is loading a page by connecting to +notify::is-loading signal of /@webView@/. This is useful when you are +interesting in knowing when the view is loading something but not in the +details about the status of the load operation, for example to start a spinner +when the view is loading a page and stop it when it finishes. +-} +webViewIsLoading :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@webView@/ is loading a page or 'False' otherwise. -} +webViewIsLoading webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_is_loading webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewIsLoadingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsLoadingMethodInfo a signature where + overloadedMethod _ = webViewIsLoading + +#endif + +-- method WebView::is_playing_audio +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_is_playing_audio" webkit_web_view_is_playing_audio :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO CInt + +{- | +Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/is-playing-audio/@ property. +You can monitor when a page in a 'GI.WebKit2.Objects.WebView.WebView' is playing audio by +connecting to the notify::is-playing-audio signal of /@webView@/. This +is useful when the application wants to provide visual feedback when a +page is producing sound. + +/Since: 2.8/ +-} +webViewIsPlayingAudio :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m Bool + {- ^ __Returns:__ 'True' if a page in /@webView@/ is playing audio or 'False' otherwise. -} +webViewIsPlayingAudio webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result <- webkit_web_view_is_playing_audio webView' + let result' = (/= 0) result + touchManagedPtr webView + return result' + +#if ENABLE_OVERLOADING +data WebViewIsPlayingAudioMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsPlayingAudioMethodInfo a signature where + overloadedMethod _ = webViewIsPlayingAudio + +#endif + +-- method WebView::load_alternate_html +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new content to display as the main page of the @web_view", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI for the alternate page content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the base URI for relative locations or %NULL", 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_view_load_alternate_html" webkit_web_view_load_alternate_html :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- content : TBasicType TUTF8 + CString -> -- content_uri : TBasicType TUTF8 + CString -> -- base_uri : TBasicType TUTF8 + IO () + +{- | +Load the given /@content@/ string for the URI /@contentUri@/. +This allows clients to display page-loading errors in the 'GI.WebKit2.Objects.WebView.WebView' itself. +When this method is called from 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal to show an +error page, then the back-forward list is maintained appropriately. +For everything else this method works the same way as 'GI.WebKit2.Objects.WebView.webViewLoadHtml'. +-} +webViewLoadAlternateHtml :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@content@/: the new content to display as the main page of the /@webView@/ -} + -> T.Text + {- ^ /@contentUri@/: the URI for the alternate page content -} + -> Maybe (T.Text) + {- ^ /@baseUri@/: the base URI for relative locations or 'Nothing' -} + -> m () +webViewLoadAlternateHtml webView content contentUri baseUri = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + content' <- textToCString content + contentUri' <- textToCString contentUri + maybeBaseUri <- case baseUri of + Nothing -> return nullPtr + Just jBaseUri -> do + jBaseUri' <- textToCString jBaseUri + return jBaseUri' + webkit_web_view_load_alternate_html webView' content' contentUri' maybeBaseUri + touchManagedPtr webView + freeMem content' + freeMem contentUri' + freeMem maybeBaseUri + return () + +#if ENABLE_OVERLOADING +data WebViewLoadAlternateHtmlMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadAlternateHtmlMethodInfo a signature where + overloadedMethod _ = webViewLoadAlternateHtml + +#endif + +-- method WebView::load_bytes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input data to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the MIME type of @bytes, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the character encoding of @bytes, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the base URI for relative locations or %NULL", 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_view_load_bytes" webkit_web_view_load_bytes :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr GLib.Bytes.Bytes -> -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"}) + CString -> -- mime_type : TBasicType TUTF8 + CString -> -- encoding : TBasicType TUTF8 + CString -> -- base_uri : TBasicType TUTF8 + IO () + +{- | +Load the specified /@bytes@/ into /@webView@/ using the given /@mimeType@/ and /@encoding@/. +When /@mimeType@/ is 'Nothing', it defaults to \"text\/html\". +When /@encoding@/ is 'Nothing', it defaults to \"UTF-8\". +When /@baseUri@/ is 'Nothing', it defaults to \"about:blank\". +You can monitor the load operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. + +/Since: 2.6/ +-} +webViewLoadBytes :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> GLib.Bytes.Bytes + {- ^ /@bytes@/: input data to load -} + -> Maybe (T.Text) + {- ^ /@mimeType@/: the MIME type of /@bytes@/, or 'Nothing' -} + -> Maybe (T.Text) + {- ^ /@encoding@/: the character encoding of /@bytes@/, or 'Nothing' -} + -> Maybe (T.Text) + {- ^ /@baseUri@/: the base URI for relative locations or 'Nothing' -} + -> m () +webViewLoadBytes webView bytes mimeType encoding baseUri = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + bytes' <- unsafeManagedPtrGetPtr bytes + maybeMimeType <- case mimeType of + Nothing -> return nullPtr + Just jMimeType -> do + jMimeType' <- textToCString jMimeType + return jMimeType' + maybeEncoding <- case encoding of + Nothing -> return nullPtr + Just jEncoding -> do + jEncoding' <- textToCString jEncoding + return jEncoding' + maybeBaseUri <- case baseUri of + Nothing -> return nullPtr + Just jBaseUri -> do + jBaseUri' <- textToCString jBaseUri + return jBaseUri' + webkit_web_view_load_bytes webView' bytes' maybeMimeType maybeEncoding maybeBaseUri + touchManagedPtr webView + touchManagedPtr bytes + freeMem maybeMimeType + freeMem maybeEncoding + freeMem maybeBaseUri + return () + +#if ENABLE_OVERLOADING +data WebViewLoadBytesMethodInfo +instance (signature ~ (GLib.Bytes.Bytes -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadBytesMethodInfo a signature where + overloadedMethod _ = webViewLoadBytes + +#endif + +-- method WebView::load_html +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The HTML string to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The base URI for relative locations or %NULL", 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_view_load_html" webkit_web_view_load_html :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- content : TBasicType TUTF8 + CString -> -- base_uri : TBasicType TUTF8 + IO () + +{- | +Load the given /@content@/ string with the specified /@baseUri@/. +If /@baseUri@/ is not 'Nothing', relative URLs in the /@content@/ will be +resolved against /@baseUri@/ and absolute local paths must be children of the /@baseUri@/. +For security reasons absolute local paths that are not children of /@baseUri@/ +will cause the web process to terminate. +If you need to include URLs in /@content@/ that are local paths in a different +directory than /@baseUri@/ you can build a data URI for them. When /@baseUri@/ is 'Nothing', +it defaults to \"about:blank\". The mime type of the document will be \"text\/html\". +You can monitor the load operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewLoadHtml :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@content@/: The HTML string to load -} + -> Maybe (T.Text) + {- ^ /@baseUri@/: The base URI for relative locations or 'Nothing' -} + -> m () +webViewLoadHtml webView content baseUri = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + content' <- textToCString content + maybeBaseUri <- case baseUri of + Nothing -> return nullPtr + Just jBaseUri -> do + jBaseUri' <- textToCString jBaseUri + return jBaseUri' + webkit_web_view_load_html webView' content' maybeBaseUri + touchManagedPtr webView + freeMem content' + freeMem maybeBaseUri + return () + +#if ENABLE_OVERLOADING +data WebViewLoadHtmlMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadHtmlMethodInfo a signature where + overloadedMethod _ = webViewLoadHtml + +#endif + +-- method WebView::load_plain_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plain_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The plain text to load", 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_view_load_plain_text" webkit_web_view_load_plain_text :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- plain_text : TBasicType TUTF8 + IO () + +{- | +Load the specified /@plainText@/ string into /@webView@/. The mime type of +document will be \"text\/plain\". You can monitor the load +operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewLoadPlainText :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@plainText@/: The plain text to load -} + -> m () +webViewLoadPlainText webView plainText = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + plainText' <- textToCString plainText + webkit_web_view_load_plain_text webView' plainText' + touchManagedPtr webView + freeMem plainText' + return () + +#if ENABLE_OVERLOADING +data WebViewLoadPlainTextMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadPlainTextMethodInfo a signature where + overloadedMethod _ = webViewLoadPlainText + +#endif + +-- method WebView::load_request +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest to load", 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_view_load_request" webkit_web_view_load_request :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr WebKit2.URIRequest.URIRequest -> -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"}) + IO () + +{- | +Requests loading of the specified 'GI.WebKit2.Objects.URIRequest.URIRequest'. +You can monitor the load operation by connecting to +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewLoadRequest :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.URIRequest.IsURIRequest b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' to load -} + -> m () +webViewLoadRequest webView request = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + request' <- unsafeManagedPtrCastPtr request + webkit_web_view_load_request webView' request' + touchManagedPtr webView + touchManagedPtr request + return () + +#if ENABLE_OVERLOADING +data WebViewLoadRequestMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.URIRequest.IsURIRequest b) => O.MethodInfo WebViewLoadRequestMethodInfo a signature where + overloadedMethod _ = webViewLoadRequest + +#endif + +-- method WebView::load_uri +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 "an URI string", 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_view_load_uri" webkit_web_view_load_uri :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- uri : TBasicType TUTF8 + IO () + +{- | +Requests loading of the specified URI string. +You can monitor the load operation by connecting to +'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal. +-} +webViewLoadUri :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@uri@/: an URI string -} + -> m () +webViewLoadUri webView uri = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + uri' <- textToCString uri + webkit_web_view_load_uri webView' uri' + touchManagedPtr webView + freeMem uri' + return () + +#if ENABLE_OVERLOADING +data WebViewLoadUriMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadUriMethodInfo a signature where + overloadedMethod _ = webViewLoadUri + +#endif + +-- method WebView::reload +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_reload" webkit_web_view_reload :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Reloads the current contents of /@webView@/. +See also 'GI.WebKit2.Objects.WebView.webViewReloadBypassCache'. +-} +webViewReload :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewReload webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_reload webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewReloadMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewReloadMethodInfo a signature where + overloadedMethod _ = webViewReload + +#endif + +-- method WebView::reload_bypass_cache +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_reload_bypass_cache" webkit_web_view_reload_bypass_cache :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Reloads the current contents of /@webView@/ without +using any cached data. +-} +webViewReloadBypassCache :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewReloadBypassCache webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_reload_bypass_cache webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewReloadBypassCacheMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewReloadBypassCacheMethodInfo a signature where + overloadedMethod _ = webViewReloadBypassCache + +#endif + +-- method WebView::restore_session_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebViewSessionState", 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_view_restore_session_state" webkit_web_view_restore_session_state :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr WebKit2.WebViewSessionState.WebViewSessionState -> -- state : TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}) + IO () + +{- | +Restore the /@webView@/ session state from /@state@/ + +/Since: 2.12/ +-} +webViewRestoreSessionState :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> WebKit2.WebViewSessionState.WebViewSessionState + {- ^ /@state@/: a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} + -> m () +webViewRestoreSessionState webView state = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + state' <- unsafeManagedPtrGetPtr state + webkit_web_view_restore_session_state webView' state' + touchManagedPtr webView + touchManagedPtr state + return () + +#if ENABLE_OVERLOADING +data WebViewRestoreSessionStateMethodInfo +instance (signature ~ (WebKit2.WebViewSessionState.WebViewSessionState -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewRestoreSessionStateMethodInfo a signature where + overloadedMethod _ = webViewRestoreSessionState + +#endif + +-- method WebView::run_javascript +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "script", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the script to run", 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 script finished", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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_view_run_javascript" webkit_web_view_run_javascript :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- script : TBasicType TUTF8 + 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 run /@script@/ in the context of the current page in /@webView@/. If +WebKitSettings:enable-javascript is FALSE, this method will do nothing. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebView.webViewRunJavascriptFinish' to get the result of the operation. +-} +webViewRunJavascript :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@script@/: the script to run -} + -> 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 script finished -} + -> m () +webViewRunJavascript webView script cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + script' <- textToCString script + 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_view_run_javascript webView' script' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + freeMem script' + return () + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewRunJavascriptMethodInfo a signature where + overloadedMethod _ = webViewRunJavascript + +#endif + +-- method WebView::run_javascript_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_run_javascript_finish" webkit_web_view_run_javascript_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.JavascriptResult.JavascriptResult) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewRunJavascript'. + +This is an example of using 'GI.WebKit2.Objects.WebView.webViewRunJavascript' with a script returning +a string: + +\\ +static void +web_view_javascript_finished (GObject *object, + GAsyncResult *result, + gpointer user_data) +{ + WebKitJavascriptResult *js_result; + JSCValue *value; + GError *error = NULL; + + js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error); + if (!js_result) { + g_warning (\"Error running javascript: @/s/@\", error->message); + g_error_free (error); + return; + } + + value = webkit_javascript_result_get_js_value (js_result); + if (jsc_value_is_string (value)) { + JSCException *exception; + gchar *str_value; + + str_value = jsc_value_to_string (value); + exception = jsc_context_get_exception (jsc_value_get_context (value)); + if (exception) + g_warning (\"Error running javascript: @/s/@\", jsc_exception_get_message (exception)); + else + g_print (\"Script result: @/s/@\\n\", str_value); + g_free (str_value); + } else { + g_warning (\"Error running javascript: unexpected return value\"); + } + webkit_javascript_result_unref (js_result); +} + +static void +web_view_get_link_url (WebKitWebView *web_view, + const gchar *link_id) +{ + gchar *script; + + script = g_strdup_printf (\"window.document.getElementById(\'@/s/@\').href;\", link_id); + webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL); + g_free (script); +} +\<\/programlisting>\<\/informalexample> +-} +webViewRunJavascriptFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.JavascriptResult.JavascriptResult + {- ^ __Returns:__ a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' with the result of the last executed statement in /@script@/ + or 'Nothing' in case of error /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewRunJavascriptFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_view_run_javascript_finish webView' result_' + checkUnexpectedReturnNULL "webViewRunJavascriptFinish" result + result' <- (wrapBoxed WebKit2.JavascriptResult.JavascriptResult) result + touchManagedPtr webView + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFinishMethodInfo +instance (signature ~ (b -> m WebKit2.JavascriptResult.JavascriptResult), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewRunJavascriptFinishMethodInfo a signature where + overloadedMethod _ = webViewRunJavascriptFinish + +#endif + +-- method WebView::run_javascript_from_gresource +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resource", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the location of the resource to load", 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 script finished", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, 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_view_run_javascript_from_gresource" webkit_web_view_run_javascript_from_gresource :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- resource : TBasicType TUTF8 + 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 run the script from /@resource@/ in the context of the +current page in /@webView@/. + +When the operation is finished, /@callback@/ will be called. You can +then call 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFromGresourceFinish' to get the result +of the operation. +-} +webViewRunJavascriptFromGresource :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@resource@/: the location of the resource to load -} + -> 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 script finished -} + -> m () +webViewRunJavascriptFromGresource webView resource cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + resource' <- textToCString 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_view_run_javascript_from_gresource webView' resource' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + freeMem resource' + return () + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFromGresourceMethodInfo +instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewRunJavascriptFromGresourceMethodInfo a signature where + overloadedMethod _ = webViewRunJavascriptFromGresource + +#endif + +-- method WebView::run_javascript_from_gresource_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_run_javascript_from_gresource_finish" webkit_web_view_run_javascript_from_gresource_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.JavascriptResult.JavascriptResult) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFromGresource'. + +Check 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFinish' for a usage example. +-} +webViewRunJavascriptFromGresourceFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.JavascriptResult.JavascriptResult + {- ^ __Returns:__ a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' with the result of the last executed statement in /@script@/ + or 'Nothing' in case of error /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewRunJavascriptFromGresourceFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_view_run_javascript_from_gresource_finish webView' result_' + checkUnexpectedReturnNULL "webViewRunJavascriptFromGresourceFinish" result + result' <- (wrapBoxed WebKit2.JavascriptResult.JavascriptResult) result + touchManagedPtr webView + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFromGresourceFinishMethodInfo +instance (signature ~ (b -> m WebKit2.JavascriptResult.JavascriptResult), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewRunJavascriptFromGresourceFinishMethodInfo a signature where + overloadedMethod _ = webViewRunJavascriptFromGresourceFinish + +#endif + +-- method WebView::run_javascript_in_world +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "script", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the script to run", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "world_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a #WebKitScriptWorld", 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 script finished", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, 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_view_run_javascript_in_world" webkit_web_view_run_javascript_in_world :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- script : TBasicType TUTF8 + CString -> -- world_name : TBasicType TUTF8 + 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 run /@script@/ in the script world with name /@worldName@/ of the current page context in /@webView@/. +If WebKitSettings:enable-javascript is FALSE, this method will do nothing. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebView.webViewRunJavascriptInWorldFinish' to get the result of the operation. + +/Since: 2.22/ +-} +webViewRunJavascriptInWorld :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> T.Text + {- ^ /@script@/: the script to run -} + -> T.Text + {- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@ -} + -> 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 script finished -} + -> m () +webViewRunJavascriptInWorld webView script worldName cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + script' <- textToCString script + worldName' <- textToCString worldName + 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_view_run_javascript_in_world webView' script' worldName' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + freeMem script' + freeMem worldName' + return () + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptInWorldMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewRunJavascriptInWorldMethodInfo a signature where + overloadedMethod _ = webViewRunJavascriptInWorld + +#endif + +-- method WebView::run_javascript_in_world_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_run_javascript_in_world_finish" webkit_web_view_run_javascript_in_world_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr WebKit2.JavascriptResult.JavascriptResult) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewRunJavascriptInWorld'. + +/Since: 2.22/ +-} +webViewRunJavascriptInWorldFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m WebKit2.JavascriptResult.JavascriptResult + {- ^ __Returns:__ a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' with the result of the last executed statement in /@script@/ + or 'Nothing' in case of error /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewRunJavascriptInWorldFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_view_run_javascript_in_world_finish webView' result_' + checkUnexpectedReturnNULL "webViewRunJavascriptInWorldFinish" result + result' <- (wrapBoxed WebKit2.JavascriptResult.JavascriptResult) result + touchManagedPtr webView + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewRunJavascriptInWorldFinishMethodInfo +instance (signature ~ (b -> m WebKit2.JavascriptResult.JavascriptResult), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewRunJavascriptInWorldFinishMethodInfo a signature where + overloadedMethod _ = webViewRunJavascriptInWorldFinish + +#endif + +-- method WebView::save +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_mode", argType = TInterface (Name {namespace = "WebKit2", name = "SaveMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSaveMode specifying how the web page should be saved.", 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 = 4, 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_view_save" webkit_web_view_save :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CUInt -> -- save_mode : TInterface (Name {namespace = "WebKit2", name = "SaveMode"}) + 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 save the current web page associated to the +'GI.WebKit2.Objects.WebView.WebView' into a self-contained format using the mode +specified in /@saveMode@/. + +When the operation is finished, /@callback@/ will be called. You can +then call 'GI.WebKit2.Objects.WebView.webViewSaveFinish' to get the result of the +operation. +-} +webViewSave :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> WebKit2.Enums.SaveMode + {- ^ /@saveMode@/: the 'GI.WebKit2.Enums.SaveMode' specifying how the web page should be saved. -} + -> 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 () +webViewSave webView saveMode cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + let saveMode' = (fromIntegral . fromEnum) saveMode + 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_view_save webView' saveMode' maybeCancellable maybeCallback userData + touchManagedPtr webView + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebViewSaveMethodInfo +instance (signature ~ (WebKit2.Enums.SaveMode -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewSaveMethodInfo a signature where + overloadedMethod _ = webViewSave + +#endif + +-- method WebView::save_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"})) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_save_finish" webkit_web_view_save_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Gio.InputStream.InputStream) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewSave'. +-} +webViewSaveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m Gio.InputStream.InputStream + {- ^ __Returns:__ a 'GI.Gio.Objects.InputStream.InputStream' with the result of saving + the current web page or 'Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewSaveFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_web_view_save_finish webView' result_' + checkUnexpectedReturnNULL "webViewSaveFinish" result + result' <- (wrapObject Gio.InputStream.InputStream) result + touchManagedPtr webView + touchManagedPtr result_ + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewSaveFinishMethodInfo +instance (signature ~ (b -> m Gio.InputStream.InputStream), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewSaveFinishMethodInfo a signature where + overloadedMethod _ = webViewSaveFinish + +#endif + +-- method WebView::save_to_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GFile where the current web page should be saved to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_mode", argType = TInterface (Name {namespace = "WebKit2", name = "SaveMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSaveMode specifying how the web page should be saved.", 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 = 5, 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_view_save_to_file" webkit_web_view_save_to_file :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + CUInt -> -- save_mode : TInterface (Name {namespace = "WebKit2", name = "SaveMode"}) + 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 save the current web page associated to the +'GI.WebKit2.Objects.WebView.WebView' into a self-contained format using the mode +specified in /@saveMode@/ and writing it to /@file@/. + +When the operation is finished, /@callback@/ will be called. You can +then call 'GI.WebKit2.Objects.WebView.webViewSaveToFileFinish' to get the result of the +operation. +-} +webViewSaveToFile :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@file@/: the 'GI.Gio.Interfaces.File.File' where the current web page should be saved to. -} + -> WebKit2.Enums.SaveMode + {- ^ /@saveMode@/: the 'GI.WebKit2.Enums.SaveMode' specifying how the web page should be saved. -} + -> Maybe (c) + {- ^ /@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 () +webViewSaveToFile webView file saveMode cancellable callback = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + file' <- unsafeManagedPtrCastPtr file + let saveMode' = (fromIntegral . fromEnum) saveMode + 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_view_save_to_file webView' file' saveMode' maybeCancellable maybeCallback userData + touchManagedPtr webView + touchManagedPtr file + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebViewSaveToFileMethodInfo +instance (signature ~ (b -> WebKit2.Enums.SaveMode -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo WebViewSaveToFileMethodInfo a signature where + overloadedMethod _ = webViewSaveToFile + +#endif + +-- method WebView::save_to_file_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_web_view_save_to_file_finish" webkit_web_view_save_to_file_finish :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewSaveToFile'. +-} +webViewSaveToFileFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +webViewSaveToFileFinish webView result_ = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_web_view_save_to_file_finish webView' result_' + touchManagedPtr webView + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebViewSaveToFileFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewSaveToFileFinishMethodInfo a signature where + overloadedMethod _ = webViewSaveToFileFinish + +#endif + +-- method WebView::set_background_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA", 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_view_set_background_color" webkit_web_view_set_background_color :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr Gdk.RGBA.RGBA -> -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Sets the color that will be used to draw the /@webView@/ background before +the actual contents are rendered. Note that if the web page loaded in /@webView@/ +specifies a background color, it will take precedence over the /@rgba@/ color. +By default the /@webView@/ background color is opaque white. +Note that the parent window must have a RGBA visual and +'GI.Gtk.Objects.Widget.Widget':@/app-paintable/@ property set to 'True' for backgrounds colors to work. + +\\ +static void browser_window_set_background_color (BrowserWindow *window, + const GdkRGBA *rgba) +{ + WebKitWebView *web_view; + GdkScreen *screen = gtk_window_get_screen (GTK_WINDOW (window)); + GdkVisual *rgba_visual = gdk_screen_get_rgba_visual (screen); + + if (!rgba_visual) + return; + + gtk_widget_set_visual (GTK_WIDGET (window), rgba_visual); + gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE); + + web_view = browser_window_get_web_view (window); + webkit_web_view_set_background_color (web_view, rgba); +} +\<\/programlisting>\<\/informalexample> + +/Since: 2.8/ +-} +webViewSetBackgroundColor :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> Gdk.RGBA.RGBA + {- ^ /@rgba@/: a 'GI.Gdk.Structs.RGBA.RGBA' -} + -> m () +webViewSetBackgroundColor webView rgba = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + rgba' <- unsafeManagedPtrGetPtr rgba + webkit_web_view_set_background_color webView' rgba' + touchManagedPtr webView + touchManagedPtr rgba + return () + +#if ENABLE_OVERLOADING +data WebViewSetBackgroundColorMethodInfo +instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetBackgroundColorMethodInfo a signature where + overloadedMethod _ = webViewSetBackgroundColor + +#endif + +-- method WebView::set_custom_charset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a character encoding name or %NULL", 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_view_set_custom_charset" webkit_web_view_set_custom_charset :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CString -> -- charset : TBasicType TUTF8 + IO () + +{- | +Sets the current custom character encoding override of /@webView@/. The custom +character encoding will override any text encoding detected via HTTP headers or +META tags. Calling this method will stop any current load operation and reload the +current page. Setting the custom character encoding to 'Nothing' removes the character +encoding override. +-} +webViewSetCustomCharset :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> Maybe (T.Text) + {- ^ /@charset@/: a character encoding name or 'Nothing' -} + -> m () +webViewSetCustomCharset webView charset = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + maybeCharset <- case charset of + Nothing -> return nullPtr + Just jCharset -> do + jCharset' <- textToCString jCharset + return jCharset' + webkit_web_view_set_custom_charset webView' maybeCharset + touchManagedPtr webView + freeMem maybeCharset + return () + +#if ENABLE_OVERLOADING +data WebViewSetCustomCharsetMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetCustomCharsetMethodInfo a signature where + overloadedMethod _ = webViewSetCustomCharset + +#endif + +-- method WebView::set_editable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean indicating the editable state", 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_view_set_editable" webkit_web_view_set_editable :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CInt -> -- editable : TBasicType TBoolean + IO () + +{- | +Sets whether the user is allowed to edit the HTML document. + +If /@editable@/ is 'True', /@webView@/ allows the user to edit the HTML document. If +/@editable@/ is 'False', an element in /@webView@/\'s document can only be edited if the +CONTENTEDITABLE attribute has been set on the element or one of its parent +elements. By default a 'GI.WebKit2.Objects.WebView.WebView' is not editable. + +Normally, a HTML document is not editable unless the elements within the +document are editable. This function provides a way to make the contents +of a 'GI.WebKit2.Objects.WebView.WebView' editable without altering the document or DOM structure. + +/Since: 2.8/ +-} +webViewSetEditable :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> Bool + {- ^ /@editable@/: a 'Bool' indicating the editable state -} + -> m () +webViewSetEditable webView editable = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + let editable' = (fromIntegral . fromEnum) editable + webkit_web_view_set_editable webView' editable' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewSetEditableMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetEditableMethodInfo a signature where + overloadedMethod _ = webViewSetEditable + +#endif + +-- method WebView::set_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_view_set_settings" webkit_web_view_set_settings :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + Ptr WebKit2.Settings.Settings -> -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"}) + IO () + +{- | +Sets the 'GI.WebKit2.Objects.Settings.Settings' to be applied to /@webView@/. The +existing 'GI.WebKit2.Objects.Settings.Settings' of /@webView@/ will be replaced by +/@settings@/. New settings are applied immediately on /@webView@/. +The same 'GI.WebKit2.Objects.Settings.Settings' object can be shared +by multiple 'GI.WebKit2.Objects.WebView.WebView'\s. +-} +webViewSetSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.Settings.IsSettings b) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> b + {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -} + -> m () +webViewSetSettings webView settings = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + settings' <- unsafeManagedPtrCastPtr settings + webkit_web_view_set_settings webView' settings' + touchManagedPtr webView + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data WebViewSetSettingsMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.Settings.IsSettings b) => O.MethodInfo WebViewSetSettingsMethodInfo a signature where + overloadedMethod _ = webViewSetSettings + +#endif + +-- method WebView::set_zoom_level +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "zoom_level", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the zoom level", 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_view_set_zoom_level" webkit_web_view_set_zoom_level :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + CDouble -> -- zoom_level : TBasicType TDouble + IO () + +{- | +Set the zoom level of /@webView@/, i.e. the factor by which the +view contents are scaled with respect to their original size. +-} +webViewSetZoomLevel :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> Double + {- ^ /@zoomLevel@/: the zoom level -} + -> m () +webViewSetZoomLevel webView zoomLevel = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + let zoomLevel' = realToFrac zoomLevel + webkit_web_view_set_zoom_level webView' zoomLevel' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewSetZoomLevelMethodInfo +instance (signature ~ (Double -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetZoomLevelMethodInfo a signature where + overloadedMethod _ = webViewSetZoomLevel + +#endif + +-- method WebView::stop_loading +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_stop_loading" webkit_web_view_stop_loading :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Stops any ongoing loading operation in /@webView@/. +This method does nothing if no content is being loaded. +If there is a loading operation in progress, it will be cancelled and +'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal will be emitted with +'GI.WebKit2.Enums.NetworkErrorCancelled' error. +-} +webViewStopLoading :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewStopLoading webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_stop_loading webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewStopLoadingMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewStopLoadingMethodInfo a signature where + overloadedMethod _ = webViewStopLoading + +#endif + +-- method WebView::try_close +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_try_close" webkit_web_view_try_close :: + Ptr WebView -> -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"}) + IO () + +{- | +Tries to close the /@webView@/. This will fire the onbeforeunload event +to ask the user for confirmation to close the page. If there isn\'t an +onbeforeunload event handler or the user confirms to close the page, +the 'GI.WebKit2.Objects.WebView.WebView'::@/close/@ signal is emitted, otherwise nothing happens. + +/Since: 2.12/ +-} +webViewTryClose :: + (B.CallStack.HasCallStack, MonadIO m, IsWebView a) => + a + {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -} + -> m () +webViewTryClose webView = liftIO $ do + webView' <- unsafeManagedPtrCastPtr webView + webkit_web_view_try_close webView' + touchManagedPtr webView + return () + +#if ENABLE_OVERLOADING +data WebViewTryCloseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewTryCloseMethodInfo a signature where + overloadedMethod _ = webViewTryClose + +#endif + + diff --git a/GI/WebKit2/Objects/WebView.hs-boot b/GI/WebKit2/Objects/WebView.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebView.hs-boot @@ -0,0 +1,341 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebView 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 + +newtype WebView = WebView (ManagedPtr WebView) +instance GObject WebView where +class (GObject o, O.IsDescendantOf WebView o) => IsWebView o +instance (GObject o, O.IsDescendantOf WebView o) => IsWebView o +instance O.HasParentTypes WebView +#if ENABLE_OVERLOADING +data WebViewEditablePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewEstimatedLoadProgressPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewFaviconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsControlledByAutomationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsEphemeralPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsLoadingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsPlayingAudioPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRelatedViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSettingsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewUriPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewUserContentManagerPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewWebContextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewZoomLevelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebViewAuthenticateSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCloseSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewContextMenuSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewContextMenuDismissedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCreateSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewDecidePolicySignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewEnterFullscreenSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewInsecureContentDetectedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLeaveFullscreenSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadFailedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadFailedWithTlsErrorsSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewMouseTargetChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewPermissionRequestSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewPrintSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewReadyToShowSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewResourceLoadStartedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunAsModalSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunColorChooserSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunFileChooserSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewScriptDialogSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewShowNotificationSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewShowOptionMenuSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSubmitFormSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewWebProcessCrashedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewWebProcessTerminatedSignalInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCanExecuteEditingCommandMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCanExecuteEditingCommandFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCanGoBackMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCanGoForwardMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewCanShowMimeTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewDownloadUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewExecuteEditingCommandMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewExecuteEditingCommandWithArgumentMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetBackForwardListMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetBackgroundColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetContextMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetCustomCharsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetEditorStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetEstimatedLoadProgressMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetFaviconMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetFindControllerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetInspectorMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetMainResourceMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetPageIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetSessionStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetSettingsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetSnapshotMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetSnapshotFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetTlsInfoMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetUserContentManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetWebsiteDataManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetWindowPropertiesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGetZoomLevelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGoBackMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGoForwardMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewGoToBackForwardListItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsControlledByAutomationMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsEditableMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsEphemeralMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsLoadingMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewIsPlayingAudioMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadAlternateHtmlMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadBytesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadHtmlMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadPlainTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadRequestMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewLoadUriMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewReloadMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewReloadBypassCacheMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRestoreSessionStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFromGresourceMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptFromGresourceFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptInWorldMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewRunJavascriptInWorldFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSaveMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSaveFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSaveToFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSaveToFileFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSetBackgroundColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSetCustomCharsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSetEditableMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSetSettingsMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSetZoomLevelMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewStopLoadingMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewTryCloseMethodInfo +#endif diff --git a/GI/WebKit2/Objects/WebViewBase.hs b/GI/WebKit2/Objects/WebViewBase.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebViewBase.hs @@ -0,0 +1,421 @@ + + +{- | +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.WebViewBase + ( + +-- * Exported types + WebViewBase(..) , + IsWebViewBase , + toWebViewBase , + noWebViewBase , + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.Widget as Gtk.Widget + +-- | Memory-managed wrapper type. +newtype WebViewBase = WebViewBase (ManagedPtr WebViewBase) +foreign import ccall "webkit_web_view_base_get_type" + c_webkit_web_view_base_get_type :: IO GType + +instance GObject WebViewBase where + gobjectType = c_webkit_web_view_base_get_type + + +-- | Type class for types which can be safely cast to `WebViewBase`, for instance with `toWebViewBase`. +class (GObject o, O.IsDescendantOf WebViewBase o) => IsWebViewBase o +instance (GObject o, O.IsDescendantOf WebViewBase o) => IsWebViewBase o + +instance O.HasParentTypes WebViewBase +type instance O.ParentTypes WebViewBase = '[Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable] + +-- | Cast to `WebViewBase`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWebViewBase :: (MonadIO m, IsWebViewBase o) => o -> m WebViewBase +toWebViewBase = liftIO . unsafeCastTo WebViewBase + +-- | A convenience alias for `Nothing` :: `Maybe` `WebViewBase`. +noWebViewBase :: Maybe WebViewBase +noWebViewBase = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWebViewBaseMethod (t :: Symbol) (o :: *) :: * where + ResolveWebViewBaseMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveWebViewBaseMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveWebViewBaseMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveWebViewBaseMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveWebViewBaseMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveWebViewBaseMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveWebViewBaseMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveWebViewBaseMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveWebViewBaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWebViewBaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWebViewBaseMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveWebViewBaseMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveWebViewBaseMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveWebViewBaseMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveWebViewBaseMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveWebViewBaseMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveWebViewBaseMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveWebViewBaseMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveWebViewBaseMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveWebViewBaseMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveWebViewBaseMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveWebViewBaseMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveWebViewBaseMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveWebViewBaseMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveWebViewBaseMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveWebViewBaseMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveWebViewBaseMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveWebViewBaseMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveWebViewBaseMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveWebViewBaseMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveWebViewBaseMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveWebViewBaseMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveWebViewBaseMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveWebViewBaseMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveWebViewBaseMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveWebViewBaseMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveWebViewBaseMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveWebViewBaseMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveWebViewBaseMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveWebViewBaseMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveWebViewBaseMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveWebViewBaseMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveWebViewBaseMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveWebViewBaseMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveWebViewBaseMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveWebViewBaseMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveWebViewBaseMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveWebViewBaseMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveWebViewBaseMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveWebViewBaseMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveWebViewBaseMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveWebViewBaseMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveWebViewBaseMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveWebViewBaseMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveWebViewBaseMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveWebViewBaseMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveWebViewBaseMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveWebViewBaseMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveWebViewBaseMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveWebViewBaseMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveWebViewBaseMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveWebViewBaseMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveWebViewBaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWebViewBaseMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveWebViewBaseMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveWebViewBaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWebViewBaseMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWebViewBaseMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveWebViewBaseMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveWebViewBaseMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveWebViewBaseMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveWebViewBaseMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveWebViewBaseMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveWebViewBaseMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveWebViewBaseMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveWebViewBaseMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveWebViewBaseMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveWebViewBaseMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveWebViewBaseMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveWebViewBaseMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveWebViewBaseMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveWebViewBaseMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveWebViewBaseMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveWebViewBaseMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveWebViewBaseMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveWebViewBaseMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveWebViewBaseMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveWebViewBaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWebViewBaseMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveWebViewBaseMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveWebViewBaseMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveWebViewBaseMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveWebViewBaseMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveWebViewBaseMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveWebViewBaseMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveWebViewBaseMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveWebViewBaseMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveWebViewBaseMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveWebViewBaseMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveWebViewBaseMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveWebViewBaseMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveWebViewBaseMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveWebViewBaseMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveWebViewBaseMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveWebViewBaseMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveWebViewBaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWebViewBaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWebViewBaseMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveWebViewBaseMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveWebViewBaseMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveWebViewBaseMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveWebViewBaseMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveWebViewBaseMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveWebViewBaseMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveWebViewBaseMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveWebViewBaseMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveWebViewBaseMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveWebViewBaseMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveWebViewBaseMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveWebViewBaseMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveWebViewBaseMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveWebViewBaseMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveWebViewBaseMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveWebViewBaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWebViewBaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWebViewBaseMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveWebViewBaseMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveWebViewBaseMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveWebViewBaseMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveWebViewBaseMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveWebViewBaseMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveWebViewBaseMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveWebViewBaseMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveWebViewBaseMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveWebViewBaseMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveWebViewBaseMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveWebViewBaseMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveWebViewBaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWebViewBaseMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveWebViewBaseMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveWebViewBaseMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveWebViewBaseMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveWebViewBaseMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveWebViewBaseMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveWebViewBaseMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveWebViewBaseMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveWebViewBaseMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveWebViewBaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWebViewBaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWebViewBaseMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveWebViewBaseMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveWebViewBaseMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveWebViewBaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWebViewBaseMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveWebViewBaseMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveWebViewBaseMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveWebViewBaseMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveWebViewBaseMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveWebViewBaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWebViewBaseMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveWebViewBaseMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveWebViewBaseMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveWebViewBaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWebViewBaseMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveWebViewBaseMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveWebViewBaseMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveWebViewBaseMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveWebViewBaseMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveWebViewBaseMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveWebViewBaseMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveWebViewBaseMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveWebViewBaseMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveWebViewBaseMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveWebViewBaseMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveWebViewBaseMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveWebViewBaseMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveWebViewBaseMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveWebViewBaseMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveWebViewBaseMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveWebViewBaseMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveWebViewBaseMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveWebViewBaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWebViewBaseMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveWebViewBaseMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveWebViewBaseMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveWebViewBaseMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveWebViewBaseMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveWebViewBaseMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveWebViewBaseMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveWebViewBaseMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveWebViewBaseMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveWebViewBaseMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveWebViewBaseMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveWebViewBaseMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveWebViewBaseMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveWebViewBaseMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveWebViewBaseMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveWebViewBaseMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveWebViewBaseMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveWebViewBaseMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveWebViewBaseMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveWebViewBaseMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveWebViewBaseMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveWebViewBaseMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveWebViewBaseMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveWebViewBaseMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveWebViewBaseMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveWebViewBaseMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveWebViewBaseMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveWebViewBaseMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveWebViewBaseMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveWebViewBaseMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveWebViewBaseMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveWebViewBaseMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveWebViewBaseMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveWebViewBaseMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveWebViewBaseMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveWebViewBaseMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveWebViewBaseMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveWebViewBaseMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveWebViewBaseMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveWebViewBaseMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveWebViewBaseMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveWebViewBaseMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveWebViewBaseMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveWebViewBaseMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveWebViewBaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWebViewBaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWebViewBaseMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveWebViewBaseMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveWebViewBaseMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveWebViewBaseMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveWebViewBaseMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveWebViewBaseMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveWebViewBaseMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveWebViewBaseMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveWebViewBaseMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveWebViewBaseMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveWebViewBaseMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveWebViewBaseMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveWebViewBaseMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveWebViewBaseMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveWebViewBaseMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveWebViewBaseMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveWebViewBaseMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveWebViewBaseMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveWebViewBaseMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveWebViewBaseMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveWebViewBaseMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveWebViewBaseMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveWebViewBaseMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveWebViewBaseMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveWebViewBaseMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveWebViewBaseMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveWebViewBaseMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveWebViewBaseMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo + ResolveWebViewBaseMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveWebViewBaseMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveWebViewBaseMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveWebViewBaseMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveWebViewBaseMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveWebViewBaseMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveWebViewBaseMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveWebViewBaseMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveWebViewBaseMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveWebViewBaseMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveWebViewBaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWebViewBaseMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveWebViewBaseMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveWebViewBaseMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveWebViewBaseMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveWebViewBaseMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveWebViewBaseMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveWebViewBaseMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveWebViewBaseMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveWebViewBaseMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveWebViewBaseMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveWebViewBaseMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveWebViewBaseMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveWebViewBaseMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveWebViewBaseMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveWebViewBaseMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveWebViewBaseMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveWebViewBaseMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveWebViewBaseMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveWebViewBaseMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveWebViewBaseMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveWebViewBaseMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveWebViewBaseMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveWebViewBaseMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveWebViewBaseMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveWebViewBaseMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveWebViewBaseMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveWebViewBaseMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveWebViewBaseMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveWebViewBaseMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveWebViewBaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWebViewBaseMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveWebViewBaseMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveWebViewBaseMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveWebViewBaseMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveWebViewBaseMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveWebViewBaseMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveWebViewBaseMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveWebViewBaseMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveWebViewBaseMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveWebViewBaseMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveWebViewBaseMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveWebViewBaseMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveWebViewBaseMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveWebViewBaseMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveWebViewBaseMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveWebViewBaseMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveWebViewBaseMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveWebViewBaseMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveWebViewBaseMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveWebViewBaseMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveWebViewBaseMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebViewBaseMethod t WebViewBase, O.MethodInfo info WebViewBase p) => OL.IsLabel t (WebViewBase -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebViewBase +type instance O.AttributeList WebViewBase = WebViewBaseAttributeList +type WebViewBaseAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList WebViewBase = WebViewBaseSignalList +type WebViewBaseSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/WebKit2/Objects/WebViewBase.hs-boot b/GI/WebKit2/Objects/WebViewBase.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebViewBase.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebViewBase 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 + +newtype WebViewBase = WebViewBase (ManagedPtr WebViewBase) +instance GObject WebViewBase where +class (GObject o, O.IsDescendantOf WebViewBase o) => IsWebViewBase o +instance (GObject o, O.IsDescendantOf WebViewBase o) => IsWebViewBase o +instance O.HasParentTypes WebViewBase diff --git a/GI/WebKit2/Objects/WebsiteDataManager.hs b/GI/WebKit2/Objects/WebsiteDataManager.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebsiteDataManager.hs @@ -0,0 +1,1438 @@ + + +{- | +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.WebsiteDataManager + ( + +-- * Exported types + WebsiteDataManager(..) , + IsWebsiteDataManager , + toWebsiteDataManager , + noWebsiteDataManager , + + + -- * Methods +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + WebsiteDataManagerClearMethodInfo , +#endif + websiteDataManagerClear , + + +-- ** clearFinish #method:clearFinish# + +#if ENABLE_OVERLOADING + WebsiteDataManagerClearFinishMethodInfo , +#endif + websiteDataManagerClearFinish , + + +-- ** fetch #method:fetch# + +#if ENABLE_OVERLOADING + WebsiteDataManagerFetchMethodInfo , +#endif + websiteDataManagerFetch , + + +-- ** fetchFinish #method:fetchFinish# + +#if ENABLE_OVERLOADING + WebsiteDataManagerFetchFinishMethodInfo , +#endif + websiteDataManagerFetchFinish , + + +-- ** getBaseCacheDirectory #method:getBaseCacheDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetBaseCacheDirectoryMethodInfo, +#endif + websiteDataManagerGetBaseCacheDirectory , + + +-- ** getBaseDataDirectory #method:getBaseDataDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetBaseDataDirectoryMethodInfo, +#endif + websiteDataManagerGetBaseDataDirectory , + + +-- ** getCookieManager #method:getCookieManager# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetCookieManagerMethodInfo, +#endif + websiteDataManagerGetCookieManager , + + +-- ** getDiskCacheDirectory #method:getDiskCacheDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetDiskCacheDirectoryMethodInfo, +#endif + websiteDataManagerGetDiskCacheDirectory , + + +-- ** getIndexeddbDirectory #method:getIndexeddbDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetIndexeddbDirectoryMethodInfo, +#endif + websiteDataManagerGetIndexeddbDirectory , + + +-- ** getLocalStorageDirectory #method:getLocalStorageDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetLocalStorageDirectoryMethodInfo, +#endif + websiteDataManagerGetLocalStorageDirectory, + + +-- ** getOfflineApplicationCacheDirectory #method:getOfflineApplicationCacheDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo, +#endif + websiteDataManagerGetOfflineApplicationCacheDirectory, + + +-- ** getWebsqlDirectory #method:getWebsqlDirectory# + +#if ENABLE_OVERLOADING + WebsiteDataManagerGetWebsqlDirectoryMethodInfo, +#endif + websiteDataManagerGetWebsqlDirectory , + + +-- ** isEphemeral #method:isEphemeral# + +#if ENABLE_OVERLOADING + WebsiteDataManagerIsEphemeralMethodInfo , +#endif + websiteDataManagerIsEphemeral , + + +-- ** newEphemeral #method:newEphemeral# + + websiteDataManagerNewEphemeral , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + WebsiteDataManagerRemoveMethodInfo , +#endif + websiteDataManagerRemove , + + +-- ** removeFinish #method:removeFinish# + +#if ENABLE_OVERLOADING + WebsiteDataManagerRemoveFinishMethodInfo, +#endif + websiteDataManagerRemoveFinish , + + + + + -- * Properties +-- ** baseCacheDirectory #attr:baseCacheDirectory# +{- | The base directory for Website cache. This is used as a base directory +for any Website cache when no specific cache directory has been provided. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerBaseCacheDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerBaseCacheDirectory, + getWebsiteDataManagerBaseCacheDirectory , +#if ENABLE_OVERLOADING + websiteDataManagerBaseCacheDirectory , +#endif + + +-- ** baseDataDirectory #attr:baseDataDirectory# +{- | The base directory for Website data. This is used as a base directory +for any Website data when no specific data directory has been provided. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerBaseDataDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerBaseDataDirectory, + getWebsiteDataManagerBaseDataDirectory , +#if ENABLE_OVERLOADING + websiteDataManagerBaseDataDirectory , +#endif + + +-- ** diskCacheDirectory #attr:diskCacheDirectory# +{- | The directory where HTTP disk cache will be stored. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerDiskCacheDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerDiskCacheDirectory, + getWebsiteDataManagerDiskCacheDirectory , +#if ENABLE_OVERLOADING + websiteDataManagerDiskCacheDirectory , +#endif + + +-- ** indexeddbDirectory #attr:indexeddbDirectory# +{- | The directory where IndexedDB databases will be stored. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerIndexeddbDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerIndexeddbDirectory, + getWebsiteDataManagerIndexeddbDirectory , +#if ENABLE_OVERLOADING + websiteDataManagerIndexeddbDirectory , +#endif + + +-- ** isEphemeral #attr:isEphemeral# +{- | Whether the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is ephemeral. An ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' +handles all websites data as non-persistent, and nothing will be written to the client +storage. Note that if you create an ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' all other construction +parameters to configure data directories will be ignored. + +/Since: 2.16/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerIsEphemeralPropertyInfo, +#endif + constructWebsiteDataManagerIsEphemeral , + getWebsiteDataManagerIsEphemeral , + + +-- ** localStorageDirectory #attr:localStorageDirectory# +{- | The directory where local storage data will be stored. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerLocalStorageDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerLocalStorageDirectory, + getWebsiteDataManagerLocalStorageDirectory, +#if ENABLE_OVERLOADING + websiteDataManagerLocalStorageDirectory , +#endif + + +-- ** offlineApplicationCacheDirectory #attr:offlineApplicationCacheDirectory# +{- | The directory where offline web application cache will be stored. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerOfflineApplicationCacheDirectory, + getWebsiteDataManagerOfflineApplicationCacheDirectory, +#if ENABLE_OVERLOADING + websiteDataManagerOfflineApplicationCacheDirectory, +#endif + + +-- ** websqlDirectory #attr:websqlDirectory# +{- | The directory where WebSQL databases will be stored. + +/Since: 2.10/ +-} +#if ENABLE_OVERLOADING + WebsiteDataManagerWebsqlDirectoryPropertyInfo, +#endif + constructWebsiteDataManagerWebsqlDirectory, + getWebsiteDataManagerWebsqlDirectory , +#if ENABLE_OVERLOADING + websiteDataManagerWebsqlDirectory , +#endif + + + + + ) 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.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags +import {-# SOURCE #-} qualified GI.WebKit2.Objects.CookieManager as WebKit2.CookieManager +import {-# SOURCE #-} qualified GI.WebKit2.Structs.WebsiteData as WebKit2.WebsiteData + +-- | Memory-managed wrapper type. +newtype WebsiteDataManager = WebsiteDataManager (ManagedPtr WebsiteDataManager) +foreign import ccall "webkit_website_data_manager_get_type" + c_webkit_website_data_manager_get_type :: IO GType + +instance GObject WebsiteDataManager where + gobjectType = c_webkit_website_data_manager_get_type + + +-- | Type class for types which can be safely cast to `WebsiteDataManager`, for instance with `toWebsiteDataManager`. +class (GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o +instance (GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o + +instance O.HasParentTypes WebsiteDataManager +type instance O.ParentTypes WebsiteDataManager = '[GObject.Object.Object] + +-- | Cast to `WebsiteDataManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWebsiteDataManager :: (MonadIO m, IsWebsiteDataManager o) => o -> m WebsiteDataManager +toWebsiteDataManager = liftIO . unsafeCastTo WebsiteDataManager + +-- | A convenience alias for `Nothing` :: `Maybe` `WebsiteDataManager`. +noWebsiteDataManager :: Maybe WebsiteDataManager +noWebsiteDataManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWebsiteDataManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveWebsiteDataManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWebsiteDataManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWebsiteDataManagerMethod "clear" o = WebsiteDataManagerClearMethodInfo + ResolveWebsiteDataManagerMethod "clearFinish" o = WebsiteDataManagerClearFinishMethodInfo + ResolveWebsiteDataManagerMethod "fetch" o = WebsiteDataManagerFetchMethodInfo + ResolveWebsiteDataManagerMethod "fetchFinish" o = WebsiteDataManagerFetchFinishMethodInfo + ResolveWebsiteDataManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWebsiteDataManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWebsiteDataManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWebsiteDataManagerMethod "isEphemeral" o = WebsiteDataManagerIsEphemeralMethodInfo + ResolveWebsiteDataManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWebsiteDataManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWebsiteDataManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWebsiteDataManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWebsiteDataManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWebsiteDataManagerMethod "remove" o = WebsiteDataManagerRemoveMethodInfo + ResolveWebsiteDataManagerMethod "removeFinish" o = WebsiteDataManagerRemoveFinishMethodInfo + ResolveWebsiteDataManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWebsiteDataManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWebsiteDataManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWebsiteDataManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWebsiteDataManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWebsiteDataManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWebsiteDataManagerMethod "getBaseCacheDirectory" o = WebsiteDataManagerGetBaseCacheDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getBaseDataDirectory" o = WebsiteDataManagerGetBaseDataDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getCookieManager" o = WebsiteDataManagerGetCookieManagerMethodInfo + ResolveWebsiteDataManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWebsiteDataManagerMethod "getDiskCacheDirectory" o = WebsiteDataManagerGetDiskCacheDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getIndexeddbDirectory" o = WebsiteDataManagerGetIndexeddbDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getLocalStorageDirectory" o = WebsiteDataManagerGetLocalStorageDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getOfflineApplicationCacheDirectory" o = WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWebsiteDataManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWebsiteDataManagerMethod "getWebsqlDirectory" o = WebsiteDataManagerGetWebsqlDirectoryMethodInfo + ResolveWebsiteDataManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWebsiteDataManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWebsiteDataManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebsiteDataManagerMethod t WebsiteDataManager, O.MethodInfo info WebsiteDataManager p) => OL.IsLabel t (WebsiteDataManager -> 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 + +-- VVV Prop "base-cache-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@base-cache-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #baseCacheDirectory +@ +-} +getWebsiteDataManagerBaseCacheDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerBaseCacheDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "base-cache-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@base-cache-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerBaseCacheDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerBaseCacheDirectory val = B.Properties.constructObjectPropertyString "base-cache-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerBaseCacheDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerBaseCacheDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerBaseCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerBaseCacheDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerBaseCacheDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerBaseCacheDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerBaseCacheDirectoryPropertyInfo = "base-cache-directory" + type AttrOrigin WebsiteDataManagerBaseCacheDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerBaseCacheDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerBaseCacheDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "base-data-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@base-data-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #baseDataDirectory +@ +-} +getWebsiteDataManagerBaseDataDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerBaseDataDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "base-data-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@base-data-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerBaseDataDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerBaseDataDirectory val = B.Properties.constructObjectPropertyString "base-data-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerBaseDataDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerBaseDataDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerBaseDataDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerBaseDataDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerBaseDataDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerBaseDataDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerBaseDataDirectoryPropertyInfo = "base-data-directory" + type AttrOrigin WebsiteDataManagerBaseDataDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerBaseDataDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerBaseDataDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "disk-cache-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@disk-cache-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #diskCacheDirectory +@ +-} +getWebsiteDataManagerDiskCacheDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerDiskCacheDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "disk-cache-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@disk-cache-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerDiskCacheDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerDiskCacheDirectory val = B.Properties.constructObjectPropertyString "disk-cache-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerDiskCacheDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerDiskCacheDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerDiskCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerDiskCacheDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerDiskCacheDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerDiskCacheDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerDiskCacheDirectoryPropertyInfo = "disk-cache-directory" + type AttrOrigin WebsiteDataManagerDiskCacheDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerDiskCacheDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerDiskCacheDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "indexeddb-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@indexeddb-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #indexeddbDirectory +@ +-} +getWebsiteDataManagerIndexeddbDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerIndexeddbDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "indexeddb-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@indexeddb-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerIndexeddbDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerIndexeddbDirectory val = B.Properties.constructObjectPropertyString "indexeddb-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerIndexeddbDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerIndexeddbDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerIndexeddbDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerIndexeddbDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerIndexeddbDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerIndexeddbDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerIndexeddbDirectoryPropertyInfo = "indexeddb-directory" + type AttrOrigin WebsiteDataManagerIndexeddbDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerIndexeddbDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerIndexeddbDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "is-ephemeral" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@is-ephemeral@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #isEphemeral +@ +-} +getWebsiteDataManagerIsEphemeral :: (MonadIO m, IsWebsiteDataManager o) => o -> m Bool +getWebsiteDataManagerIsEphemeral obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-ephemeral" + +{- | +Construct a `GValueConstruct` with valid value for the “@is-ephemeral@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerIsEphemeral :: (IsWebsiteDataManager o) => Bool -> IO (GValueConstruct o) +constructWebsiteDataManagerIsEphemeral val = B.Properties.constructObjectPropertyBool "is-ephemeral" val + +#if ENABLE_OVERLOADING +data WebsiteDataManagerIsEphemeralPropertyInfo +instance AttrInfo WebsiteDataManagerIsEphemeralPropertyInfo where + type AttrAllowedOps WebsiteDataManagerIsEphemeralPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WebsiteDataManagerIsEphemeralPropertyInfo = (~) Bool + type AttrBaseTypeConstraint WebsiteDataManagerIsEphemeralPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerIsEphemeralPropertyInfo = Bool + type AttrLabel WebsiteDataManagerIsEphemeralPropertyInfo = "is-ephemeral" + type AttrOrigin WebsiteDataManagerIsEphemeralPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerIsEphemeral + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerIsEphemeral + attrClear _ = undefined +#endif + +-- VVV Prop "local-storage-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@local-storage-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #localStorageDirectory +@ +-} +getWebsiteDataManagerLocalStorageDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerLocalStorageDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "local-storage-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@local-storage-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerLocalStorageDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerLocalStorageDirectory val = B.Properties.constructObjectPropertyString "local-storage-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerLocalStorageDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerLocalStorageDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerLocalStorageDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerLocalStorageDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerLocalStorageDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerLocalStorageDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerLocalStorageDirectoryPropertyInfo = "local-storage-directory" + type AttrOrigin WebsiteDataManagerLocalStorageDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerLocalStorageDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerLocalStorageDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "offline-application-cache-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@offline-application-cache-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #offlineApplicationCacheDirectory +@ +-} +getWebsiteDataManagerOfflineApplicationCacheDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerOfflineApplicationCacheDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "offline-application-cache-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@offline-application-cache-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerOfflineApplicationCacheDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerOfflineApplicationCacheDirectory val = B.Properties.constructObjectPropertyString "offline-application-cache-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = "offline-application-cache-directory" + type AttrOrigin WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerOfflineApplicationCacheDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerOfflineApplicationCacheDirectory + attrClear _ = undefined +#endif + +-- VVV Prop "websql-directory" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@websql-directory@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' websiteDataManager #websqlDirectory +@ +-} +getWebsiteDataManagerWebsqlDirectory :: (MonadIO m, IsWebsiteDataManager o) => o -> m (Maybe T.Text) +getWebsiteDataManagerWebsqlDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "websql-directory" + +{- | +Construct a `GValueConstruct` with valid value for the “@websql-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWebsiteDataManagerWebsqlDirectory :: (IsWebsiteDataManager o) => T.Text -> IO (GValueConstruct o) +constructWebsiteDataManagerWebsqlDirectory val = B.Properties.constructObjectPropertyString "websql-directory" (Just val) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerWebsqlDirectoryPropertyInfo +instance AttrInfo WebsiteDataManagerWebsqlDirectoryPropertyInfo where + type AttrAllowedOps WebsiteDataManagerWebsqlDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WebsiteDataManagerWebsqlDirectoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint WebsiteDataManagerWebsqlDirectoryPropertyInfo = IsWebsiteDataManager + type AttrGetType WebsiteDataManagerWebsqlDirectoryPropertyInfo = (Maybe T.Text) + type AttrLabel WebsiteDataManagerWebsqlDirectoryPropertyInfo = "websql-directory" + type AttrOrigin WebsiteDataManagerWebsqlDirectoryPropertyInfo = WebsiteDataManager + attrGet _ = getWebsiteDataManagerWebsqlDirectory + attrSet _ = undefined + attrConstruct _ = constructWebsiteDataManagerWebsqlDirectory + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebsiteDataManager +type instance O.AttributeList WebsiteDataManager = WebsiteDataManagerAttributeList +type WebsiteDataManagerAttributeList = ('[ '("baseCacheDirectory", WebsiteDataManagerBaseCacheDirectoryPropertyInfo), '("baseDataDirectory", WebsiteDataManagerBaseDataDirectoryPropertyInfo), '("diskCacheDirectory", WebsiteDataManagerDiskCacheDirectoryPropertyInfo), '("indexeddbDirectory", WebsiteDataManagerIndexeddbDirectoryPropertyInfo), '("isEphemeral", WebsiteDataManagerIsEphemeralPropertyInfo), '("localStorageDirectory", WebsiteDataManagerLocalStorageDirectoryPropertyInfo), '("offlineApplicationCacheDirectory", WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo), '("websqlDirectory", WebsiteDataManagerWebsqlDirectoryPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +websiteDataManagerBaseCacheDirectory :: AttrLabelProxy "baseCacheDirectory" +websiteDataManagerBaseCacheDirectory = AttrLabelProxy + +websiteDataManagerBaseDataDirectory :: AttrLabelProxy "baseDataDirectory" +websiteDataManagerBaseDataDirectory = AttrLabelProxy + +websiteDataManagerDiskCacheDirectory :: AttrLabelProxy "diskCacheDirectory" +websiteDataManagerDiskCacheDirectory = AttrLabelProxy + +websiteDataManagerIndexeddbDirectory :: AttrLabelProxy "indexeddbDirectory" +websiteDataManagerIndexeddbDirectory = AttrLabelProxy + +websiteDataManagerLocalStorageDirectory :: AttrLabelProxy "localStorageDirectory" +websiteDataManagerLocalStorageDirectory = AttrLabelProxy + +websiteDataManagerOfflineApplicationCacheDirectory :: AttrLabelProxy "offlineApplicationCacheDirectory" +websiteDataManagerOfflineApplicationCacheDirectory = AttrLabelProxy + +websiteDataManagerWebsqlDirectory :: AttrLabelProxy "websqlDirectory" +websiteDataManagerWebsqlDirectory = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList WebsiteDataManager = WebsiteDataManagerSignalList +type WebsiteDataManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WebsiteDataManager::new_ephemeral +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_new_ephemeral" webkit_website_data_manager_new_ephemeral :: + IO (Ptr WebsiteDataManager) + +{- | +Creates an ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. See 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/is-ephemeral/@ for more details. + +/Since: 2.16/ +-} +websiteDataManagerNewEphemeral :: + (B.CallStack.HasCallStack, MonadIO m) => + m WebsiteDataManager + {- ^ __Returns:__ a new ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. -} +websiteDataManagerNewEphemeral = liftIO $ do + result <- webkit_website_data_manager_new_ephemeral + checkUnexpectedReturnNULL "websiteDataManagerNewEphemeral" result + result' <- (wrapObject WebsiteDataManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebsiteDataManager::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#WebKitWebsiteDataTypes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timespan", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTimeSpan", 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 = 5, 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_website_data_manager_clear" webkit_website_data_manager_clear :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + CUInt -> -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}) + Int64 -> -- timespan : TBasicType TInt64 + 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 clear the website data of the given /@types@/ modified in the past /@timespan@/. +If /@timespan@/ is 0, all website data will be removed. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClearFinish' to get the result of the operation. + +Due to implementation limitations, this function does not currently delete +any stored cookies if /@timespan@/ is nonzero. This behavior may change in the +future. + +/Since: 2.16/ +-} +websiteDataManagerClear :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> [WebKit2.Flags.WebsiteDataTypes] + {- ^ /@types@/: 'GI.WebKit2.Flags.WebsiteDataTypes' -} + -> Int64 + {- ^ /@timespan@/: a @/GTimeSpan/@ -} + -> 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 () +websiteDataManagerClear manager types timespan cancellable callback = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + let types' = gflagsToWord types + 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_website_data_manager_clear manager' types' timespan maybeCancellable maybeCallback userData + touchManagedPtr manager + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebsiteDataManagerClearMethodInfo +instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> Int64 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebsiteDataManagerClearMethodInfo a signature where + overloadedMethod _ = websiteDataManagerClear + +#endif + +-- method WebsiteDataManager::clear_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_clear_finish" webkit_website_data_manager_clear_finish :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear' + +/Since: 2.16/ +-} +websiteDataManagerClearFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +websiteDataManagerClearFinish manager result_ = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_website_data_manager_clear_finish manager' result_' + touchManagedPtr manager + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerClearFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebsiteDataManagerClearFinishMethodInfo a signature where + overloadedMethod _ = websiteDataManagerClearFinish + +#endif + +-- method WebsiteDataManager::fetch +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#WebKitWebsiteDataTypes", 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 = 4, 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_website_data_manager_fetch" webkit_website_data_manager_fetch :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + CUInt -> -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}) + 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 list of 'GI.WebKit2.Structs.WebsiteData.WebsiteData' for the given /@types@/. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetchFinish' to get the result of the operation. + +/Since: 2.16/ +-} +websiteDataManagerFetch :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> [WebKit2.Flags.WebsiteDataTypes] + {- ^ /@types@/: 'GI.WebKit2.Flags.WebsiteDataTypes' -} + -> 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 () +websiteDataManagerFetch manager types cancellable callback = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + let types' = gflagsToWord types + 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_website_data_manager_fetch manager' types' maybeCancellable maybeCallback userData + touchManagedPtr manager + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data WebsiteDataManagerFetchMethodInfo +instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebsiteDataManagerFetchMethodInfo a signature where + overloadedMethod _ = websiteDataManagerFetch + +#endif + +-- method WebsiteDataManager::fetch_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}))) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_fetch_finish" webkit_website_data_manager_fetch_finish :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr (GList (Ptr WebKit2.WebsiteData.WebsiteData))) + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetch'. + +/Since: 2.16/ +-} +websiteDataManagerFetchFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m [WebKit2.WebsiteData.WebsiteData] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Structs.WebsiteData.WebsiteData'. You must free the 'GI.GLib.Structs.List.List' with + @/g_list_free()/@ and unref the 'GI.WebKit2.Structs.WebsiteData.WebsiteData'\s with 'GI.WebKit2.Structs.WebsiteData.websiteDataUnref' when you\'re done with them. /(Can throw 'Data.GI.Base.GError.GError')/ -} +websiteDataManagerFetchFinish manager result_ = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + result <- propagateGError $ webkit_website_data_manager_fetch_finish manager' result_' + result' <- unpackGList result + result'' <- mapM (wrapBoxed WebKit2.WebsiteData.WebsiteData) result' + g_list_free result + touchManagedPtr manager + touchManagedPtr result_ + return result'' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerFetchFinishMethodInfo +instance (signature ~ (b -> m [WebKit2.WebsiteData.WebsiteData]), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebsiteDataManagerFetchFinishMethodInfo a signature where + overloadedMethod _ = websiteDataManagerFetchFinish + +#endif + +-- method WebsiteDataManager::get_base_cache_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_base_cache_directory" webkit_website_data_manager_get_base_cache_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-cache-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetBaseCacheDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the base directory for Website cache, or 'Nothing' if + 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-cache-directory/@ was not provided or /@manager@/ is ephemeral. -} +websiteDataManagerGetBaseCacheDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_base_cache_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetBaseCacheDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetBaseCacheDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetBaseCacheDirectory + +#endif + +-- method WebsiteDataManager::get_base_data_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_base_data_directory" webkit_website_data_manager_get_base_data_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-data-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetBaseDataDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the base directory for Website data, or 'Nothing' if + 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/base-data-directory/@ was not provided or /@manager@/ is ephemeral. -} +websiteDataManagerGetBaseDataDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_base_data_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetBaseDataDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetBaseDataDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetBaseDataDirectory + +#endif + +-- method WebsiteDataManager::get_cookie_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CookieManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_get_cookie_manager" webkit_website_data_manager_get_cookie_manager :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO (Ptr WebKit2.CookieManager.CookieManager) + +{- | +Get the 'GI.WebKit2.Objects.CookieManager.CookieManager' of /@manager@/. + +/Since: 2.16/ +-} +websiteDataManagerGetCookieManager :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m WebKit2.CookieManager.CookieManager + {- ^ __Returns:__ a 'GI.WebKit2.Objects.CookieManager.CookieManager' -} +websiteDataManagerGetCookieManager manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_cookie_manager manager' + checkUnexpectedReturnNULL "websiteDataManagerGetCookieManager" result + result' <- (newObject WebKit2.CookieManager.CookieManager) result + touchManagedPtr manager + return result' + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetCookieManagerMethodInfo +instance (signature ~ (m WebKit2.CookieManager.CookieManager), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetCookieManagerMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetCookieManager + +#endif + +-- method WebsiteDataManager::get_disk_cache_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_disk_cache_directory" webkit_website_data_manager_get_disk_cache_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/disk-cache-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetDiskCacheDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the directory where HTTP disk cache is stored or 'Nothing' if /@manager@/ is ephemeral. -} +websiteDataManagerGetDiskCacheDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_disk_cache_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetDiskCacheDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetDiskCacheDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetDiskCacheDirectory + +#endif + +-- method WebsiteDataManager::get_indexeddb_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_indexeddb_directory" webkit_website_data_manager_get_indexeddb_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/indexeddb-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetIndexeddbDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the directory where IndexedDB databases are stored or 'Nothing' if /@manager@/ is ephemeral. -} +websiteDataManagerGetIndexeddbDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_indexeddb_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetIndexeddbDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetIndexeddbDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetIndexeddbDirectory + +#endif + +-- method WebsiteDataManager::get_local_storage_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_local_storage_directory" webkit_website_data_manager_get_local_storage_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/local-storage-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetLocalStorageDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the directory where local storage data is stored or 'Nothing' if /@manager@/ is ephemeral. -} +websiteDataManagerGetLocalStorageDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_local_storage_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetLocalStorageDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetLocalStorageDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetLocalStorageDirectory + +#endif + +-- method WebsiteDataManager::get_offline_application_cache_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_offline_application_cache_directory" webkit_website_data_manager_get_offline_application_cache_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/offline-application-cache-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetOfflineApplicationCacheDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the directory where offline web application cache is stored or 'Nothing' if /@manager@/ is ephemeral. -} +websiteDataManagerGetOfflineApplicationCacheDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_offline_application_cache_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetOfflineApplicationCacheDirectory + +#endif + +-- method WebsiteDataManager::get_websql_directory +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", 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_website_data_manager_get_websql_directory" webkit_website_data_manager_get_websql_directory :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CString + +{- | +Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/websql-directory/@ property. + +/Since: 2.10/ +-} +websiteDataManagerGetWebsqlDirectory :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the directory where WebSQL databases are stored or 'Nothing' if /@manager@/ is ephemeral. -} +websiteDataManagerGetWebsqlDirectory manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_get_websql_directory manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetWebsqlDirectoryMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerGetWebsqlDirectoryMethodInfo a signature where + overloadedMethod _ = websiteDataManagerGetWebsqlDirectory + +#endif + +-- method WebsiteDataManager::is_ephemeral +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_is_ephemeral" webkit_website_data_manager_is_ephemeral :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + IO CInt + +{- | +Get whether a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is ephemeral. See 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager':@/is-ephemeral/@ for more details. + +/Since: 2.16/ +-} +websiteDataManagerIsEphemeral :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@manager@/ is epheral or 'False' otherwise. -} +websiteDataManagerIsEphemeral manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- webkit_website_data_manager_is_ephemeral manager' + let result' = (/= 0) result + touchManagedPtr manager + return result' + +#if ENABLE_OVERLOADING +data WebsiteDataManagerIsEphemeralMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWebsiteDataManager a) => O.MethodInfo WebsiteDataManagerIsEphemeralMethodInfo a signature where + overloadedMethod _ = websiteDataManagerIsEphemeral + +#endif + +-- method WebsiteDataManager::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#WebKitWebsiteDataTypes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "website_data", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "WebsiteData"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of #WebKitWebsiteData", 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 = 5, 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_website_data_manager_remove" webkit_website_data_manager_remove :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + CUInt -> -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}) + Ptr (GList (Ptr WebKit2.WebsiteData.WebsiteData)) -> -- website_data : TGList (TInterface (Name {namespace = "WebKit2", name = "WebsiteData"})) + 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 removes the website data of the for the given /@types@/ for websites in the given /@websiteData@/ list. +Use 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerClear' if you want to remove the website data for all sites. + +When the operation is finished, /@callback@/ will be called. You can then call +'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemoveFinish' to get the result of the operation. + +/Since: 2.16/ +-} +websiteDataManagerRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> [WebKit2.Flags.WebsiteDataTypes] + {- ^ /@types@/: 'GI.WebKit2.Flags.WebsiteDataTypes' -} + -> [WebKit2.WebsiteData.WebsiteData] + {- ^ /@websiteData@/: a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> 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 () +websiteDataManagerRemove manager types websiteData cancellable callback = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + let types' = gflagsToWord types + websiteData' <- mapM unsafeManagedPtrGetPtr websiteData + websiteData'' <- packGList websiteData' + 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_website_data_manager_remove manager' types' websiteData'' maybeCancellable maybeCallback userData + touchManagedPtr manager + mapM_ touchManagedPtr websiteData + whenJust cancellable touchManagedPtr + g_list_free websiteData'' + return () + +#if ENABLE_OVERLOADING +data WebsiteDataManagerRemoveMethodInfo +instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> [WebKit2.WebsiteData.WebsiteData] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebsiteDataManagerRemoveMethodInfo a signature where + overloadedMethod _ = websiteDataManagerRemove + +#endif + +-- method WebsiteDataManager::remove_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "webkit_website_data_manager_remove_finish" webkit_website_data_manager_remove_finish :: + Ptr WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerRemove'. + +/Since: 2.16/ +-} +websiteDataManagerRemoveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +websiteDataManagerRemoveFinish manager result_ = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ webkit_website_data_manager_remove_finish manager' result_' + touchManagedPtr manager + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data WebsiteDataManagerRemoveFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsWebsiteDataManager a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebsiteDataManagerRemoveFinishMethodInfo a signature where + overloadedMethod _ = websiteDataManagerRemoveFinish + +#endif + + diff --git a/GI/WebKit2/Objects/WebsiteDataManager.hs-boot b/GI/WebKit2/Objects/WebsiteDataManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WebsiteDataManager.hs-boot @@ -0,0 +1,98 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WebsiteDataManager 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 + +newtype WebsiteDataManager = WebsiteDataManager (ManagedPtr WebsiteDataManager) +instance GObject WebsiteDataManager where +class (GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o +instance (GObject o, O.IsDescendantOf WebsiteDataManager o) => IsWebsiteDataManager o +instance O.HasParentTypes WebsiteDataManager +#if ENABLE_OVERLOADING +data WebsiteDataManagerBaseCacheDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerBaseDataDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerDiskCacheDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerIndexeddbDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerIsEphemeralPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerLocalStorageDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerOfflineApplicationCacheDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerWebsqlDirectoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerClearFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerFetchMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerFetchFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetBaseCacheDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetBaseDataDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetCookieManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetDiskCacheDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetIndexeddbDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetLocalStorageDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetOfflineApplicationCacheDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerGetWebsqlDirectoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerIsEphemeralMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataManagerRemoveFinishMethodInfo +#endif diff --git a/GI/WebKit2/Objects/WindowProperties.hs b/GI/WebKit2/Objects/WindowProperties.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WindowProperties.hs @@ -0,0 +1,905 @@ + + +{- | +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.WindowProperties + ( + +-- * Exported types + WindowProperties(..) , + IsWindowProperties , + toWindowProperties , + noWindowProperties , + + + -- * Methods +-- ** getFullscreen #method:getFullscreen# + +#if ENABLE_OVERLOADING + WindowPropertiesGetFullscreenMethodInfo , +#endif + windowPropertiesGetFullscreen , + + +-- ** getGeometry #method:getGeometry# + +#if ENABLE_OVERLOADING + WindowPropertiesGetGeometryMethodInfo , +#endif + windowPropertiesGetGeometry , + + +-- ** getLocationbarVisible #method:getLocationbarVisible# + +#if ENABLE_OVERLOADING + WindowPropertiesGetLocationbarVisibleMethodInfo, +#endif + windowPropertiesGetLocationbarVisible , + + +-- ** getMenubarVisible #method:getMenubarVisible# + +#if ENABLE_OVERLOADING + WindowPropertiesGetMenubarVisibleMethodInfo, +#endif + windowPropertiesGetMenubarVisible , + + +-- ** getResizable #method:getResizable# + +#if ENABLE_OVERLOADING + WindowPropertiesGetResizableMethodInfo , +#endif + windowPropertiesGetResizable , + + +-- ** getScrollbarsVisible #method:getScrollbarsVisible# + +#if ENABLE_OVERLOADING + WindowPropertiesGetScrollbarsVisibleMethodInfo, +#endif + windowPropertiesGetScrollbarsVisible , + + +-- ** getStatusbarVisible #method:getStatusbarVisible# + +#if ENABLE_OVERLOADING + WindowPropertiesGetStatusbarVisibleMethodInfo, +#endif + windowPropertiesGetStatusbarVisible , + + +-- ** getToolbarVisible #method:getToolbarVisible# + +#if ENABLE_OVERLOADING + WindowPropertiesGetToolbarVisibleMethodInfo, +#endif + windowPropertiesGetToolbarVisible , + + + + + -- * Properties +-- ** fullscreen #attr:fullscreen# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesFullscreenPropertyInfo , +#endif + constructWindowPropertiesFullscreen , + getWindowPropertiesFullscreen , +#if ENABLE_OVERLOADING + windowPropertiesFullscreen , +#endif + + +-- ** geometry #attr:geometry# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesGeometryPropertyInfo , +#endif + constructWindowPropertiesGeometry , + getWindowPropertiesGeometry , +#if ENABLE_OVERLOADING + windowPropertiesGeometry , +#endif + + +-- ** locationbarVisible #attr:locationbarVisible# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesLocationbarVisiblePropertyInfo, +#endif + constructWindowPropertiesLocationbarVisible, + getWindowPropertiesLocationbarVisible , +#if ENABLE_OVERLOADING + windowPropertiesLocationbarVisible , +#endif + + +-- ** menubarVisible #attr:menubarVisible# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesMenubarVisiblePropertyInfo, +#endif + constructWindowPropertiesMenubarVisible , + getWindowPropertiesMenubarVisible , +#if ENABLE_OVERLOADING + windowPropertiesMenubarVisible , +#endif + + +-- ** resizable #attr:resizable# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesResizablePropertyInfo , +#endif + constructWindowPropertiesResizable , + getWindowPropertiesResizable , +#if ENABLE_OVERLOADING + windowPropertiesResizable , +#endif + + +-- ** scrollbarsVisible #attr:scrollbarsVisible# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesScrollbarsVisiblePropertyInfo, +#endif + constructWindowPropertiesScrollbarsVisible, + getWindowPropertiesScrollbarsVisible , +#if ENABLE_OVERLOADING + windowPropertiesScrollbarsVisible , +#endif + + +-- ** statusbarVisible #attr:statusbarVisible# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesStatusbarVisiblePropertyInfo, +#endif + constructWindowPropertiesStatusbarVisible, + getWindowPropertiesStatusbarVisible , +#if ENABLE_OVERLOADING + windowPropertiesStatusbarVisible , +#endif + + +-- ** toolbarVisible #attr:toolbarVisible# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + WindowPropertiesToolbarVisiblePropertyInfo, +#endif + constructWindowPropertiesToolbarVisible , + getWindowPropertiesToolbarVisible , +#if ENABLE_OVERLOADING + windowPropertiesToolbarVisible , +#endif + + + + + ) 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.Gdk.Structs.Rectangle as Gdk.Rectangle + +-- | Memory-managed wrapper type. +newtype WindowProperties = WindowProperties (ManagedPtr WindowProperties) +foreign import ccall "webkit_window_properties_get_type" + c_webkit_window_properties_get_type :: IO GType + +instance GObject WindowProperties where + gobjectType = c_webkit_window_properties_get_type + + +-- | Type class for types which can be safely cast to `WindowProperties`, for instance with `toWindowProperties`. +class (GObject o, O.IsDescendantOf WindowProperties o) => IsWindowProperties o +instance (GObject o, O.IsDescendantOf WindowProperties o) => IsWindowProperties o + +instance O.HasParentTypes WindowProperties +type instance O.ParentTypes WindowProperties = '[GObject.Object.Object] + +-- | Cast to `WindowProperties`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toWindowProperties :: (MonadIO m, IsWindowProperties o) => o -> m WindowProperties +toWindowProperties = liftIO . unsafeCastTo WindowProperties + +-- | A convenience alias for `Nothing` :: `Maybe` `WindowProperties`. +noWindowProperties :: Maybe WindowProperties +noWindowProperties = Nothing + +#if ENABLE_OVERLOADING +type family ResolveWindowPropertiesMethod (t :: Symbol) (o :: *) :: * where + ResolveWindowPropertiesMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveWindowPropertiesMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveWindowPropertiesMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveWindowPropertiesMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveWindowPropertiesMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveWindowPropertiesMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveWindowPropertiesMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveWindowPropertiesMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveWindowPropertiesMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveWindowPropertiesMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveWindowPropertiesMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveWindowPropertiesMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveWindowPropertiesMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveWindowPropertiesMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveWindowPropertiesMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveWindowPropertiesMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveWindowPropertiesMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveWindowPropertiesMethod "getFullscreen" o = WindowPropertiesGetFullscreenMethodInfo + ResolveWindowPropertiesMethod "getGeometry" o = WindowPropertiesGetGeometryMethodInfo + ResolveWindowPropertiesMethod "getLocationbarVisible" o = WindowPropertiesGetLocationbarVisibleMethodInfo + ResolveWindowPropertiesMethod "getMenubarVisible" o = WindowPropertiesGetMenubarVisibleMethodInfo + ResolveWindowPropertiesMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveWindowPropertiesMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveWindowPropertiesMethod "getResizable" o = WindowPropertiesGetResizableMethodInfo + ResolveWindowPropertiesMethod "getScrollbarsVisible" o = WindowPropertiesGetScrollbarsVisibleMethodInfo + ResolveWindowPropertiesMethod "getStatusbarVisible" o = WindowPropertiesGetStatusbarVisibleMethodInfo + ResolveWindowPropertiesMethod "getToolbarVisible" o = WindowPropertiesGetToolbarVisibleMethodInfo + ResolveWindowPropertiesMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveWindowPropertiesMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveWindowPropertiesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWindowPropertiesMethod t WindowProperties, O.MethodInfo info WindowProperties p) => OL.IsLabel t (WindowProperties -> 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 + +-- VVV Prop "fullscreen" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@fullscreen@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #fullscreen +@ +-} +getWindowPropertiesFullscreen :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesFullscreen obj = liftIO $ B.Properties.getObjectPropertyBool obj "fullscreen" + +{- | +Construct a `GValueConstruct` with valid value for the “@fullscreen@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesFullscreen :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesFullscreen val = B.Properties.constructObjectPropertyBool "fullscreen" val + +#if ENABLE_OVERLOADING +data WindowPropertiesFullscreenPropertyInfo +instance AttrInfo WindowPropertiesFullscreenPropertyInfo where + type AttrAllowedOps WindowPropertiesFullscreenPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesFullscreenPropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesFullscreenPropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesFullscreenPropertyInfo = Bool + type AttrLabel WindowPropertiesFullscreenPropertyInfo = "fullscreen" + type AttrOrigin WindowPropertiesFullscreenPropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesFullscreen + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesFullscreen + attrClear _ = undefined +#endif + +-- VVV Prop "geometry" + -- Type: TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@geometry@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #geometry +@ +-} +getWindowPropertiesGeometry :: (MonadIO m, IsWindowProperties o) => o -> m (Maybe Gdk.Rectangle.Rectangle) +getWindowPropertiesGeometry obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "geometry" Gdk.Rectangle.Rectangle + +{- | +Construct a `GValueConstruct` with valid value for the “@geometry@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesGeometry :: (IsWindowProperties o) => Gdk.Rectangle.Rectangle -> IO (GValueConstruct o) +constructWindowPropertiesGeometry val = B.Properties.constructObjectPropertyBoxed "geometry" (Just val) + +#if ENABLE_OVERLOADING +data WindowPropertiesGeometryPropertyInfo +instance AttrInfo WindowPropertiesGeometryPropertyInfo where + type AttrAllowedOps WindowPropertiesGeometryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint WindowPropertiesGeometryPropertyInfo = (~) Gdk.Rectangle.Rectangle + type AttrBaseTypeConstraint WindowPropertiesGeometryPropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesGeometryPropertyInfo = (Maybe Gdk.Rectangle.Rectangle) + type AttrLabel WindowPropertiesGeometryPropertyInfo = "geometry" + type AttrOrigin WindowPropertiesGeometryPropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesGeometry + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesGeometry + attrClear _ = undefined +#endif + +-- VVV Prop "locationbar-visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@locationbar-visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #locationbarVisible +@ +-} +getWindowPropertiesLocationbarVisible :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesLocationbarVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "locationbar-visible" + +{- | +Construct a `GValueConstruct` with valid value for the “@locationbar-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesLocationbarVisible :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesLocationbarVisible val = B.Properties.constructObjectPropertyBool "locationbar-visible" val + +#if ENABLE_OVERLOADING +data WindowPropertiesLocationbarVisiblePropertyInfo +instance AttrInfo WindowPropertiesLocationbarVisiblePropertyInfo where + type AttrAllowedOps WindowPropertiesLocationbarVisiblePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesLocationbarVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesLocationbarVisiblePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesLocationbarVisiblePropertyInfo = Bool + type AttrLabel WindowPropertiesLocationbarVisiblePropertyInfo = "locationbar-visible" + type AttrOrigin WindowPropertiesLocationbarVisiblePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesLocationbarVisible + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesLocationbarVisible + attrClear _ = undefined +#endif + +-- VVV Prop "menubar-visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@menubar-visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #menubarVisible +@ +-} +getWindowPropertiesMenubarVisible :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesMenubarVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "menubar-visible" + +{- | +Construct a `GValueConstruct` with valid value for the “@menubar-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesMenubarVisible :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesMenubarVisible val = B.Properties.constructObjectPropertyBool "menubar-visible" val + +#if ENABLE_OVERLOADING +data WindowPropertiesMenubarVisiblePropertyInfo +instance AttrInfo WindowPropertiesMenubarVisiblePropertyInfo where + type AttrAllowedOps WindowPropertiesMenubarVisiblePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesMenubarVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesMenubarVisiblePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesMenubarVisiblePropertyInfo = Bool + type AttrLabel WindowPropertiesMenubarVisiblePropertyInfo = "menubar-visible" + type AttrOrigin WindowPropertiesMenubarVisiblePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesMenubarVisible + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesMenubarVisible + attrClear _ = undefined +#endif + +-- VVV Prop "resizable" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@resizable@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #resizable +@ +-} +getWindowPropertiesResizable :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesResizable obj = liftIO $ B.Properties.getObjectPropertyBool obj "resizable" + +{- | +Construct a `GValueConstruct` with valid value for the “@resizable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesResizable :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesResizable val = B.Properties.constructObjectPropertyBool "resizable" val + +#if ENABLE_OVERLOADING +data WindowPropertiesResizablePropertyInfo +instance AttrInfo WindowPropertiesResizablePropertyInfo where + type AttrAllowedOps WindowPropertiesResizablePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesResizablePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesResizablePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesResizablePropertyInfo = Bool + type AttrLabel WindowPropertiesResizablePropertyInfo = "resizable" + type AttrOrigin WindowPropertiesResizablePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesResizable + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesResizable + attrClear _ = undefined +#endif + +-- VVV Prop "scrollbars-visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@scrollbars-visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #scrollbarsVisible +@ +-} +getWindowPropertiesScrollbarsVisible :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesScrollbarsVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "scrollbars-visible" + +{- | +Construct a `GValueConstruct` with valid value for the “@scrollbars-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesScrollbarsVisible :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesScrollbarsVisible val = B.Properties.constructObjectPropertyBool "scrollbars-visible" val + +#if ENABLE_OVERLOADING +data WindowPropertiesScrollbarsVisiblePropertyInfo +instance AttrInfo WindowPropertiesScrollbarsVisiblePropertyInfo where + type AttrAllowedOps WindowPropertiesScrollbarsVisiblePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesScrollbarsVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesScrollbarsVisiblePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesScrollbarsVisiblePropertyInfo = Bool + type AttrLabel WindowPropertiesScrollbarsVisiblePropertyInfo = "scrollbars-visible" + type AttrOrigin WindowPropertiesScrollbarsVisiblePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesScrollbarsVisible + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesScrollbarsVisible + attrClear _ = undefined +#endif + +-- VVV Prop "statusbar-visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@statusbar-visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #statusbarVisible +@ +-} +getWindowPropertiesStatusbarVisible :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesStatusbarVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "statusbar-visible" + +{- | +Construct a `GValueConstruct` with valid value for the “@statusbar-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesStatusbarVisible :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesStatusbarVisible val = B.Properties.constructObjectPropertyBool "statusbar-visible" val + +#if ENABLE_OVERLOADING +data WindowPropertiesStatusbarVisiblePropertyInfo +instance AttrInfo WindowPropertiesStatusbarVisiblePropertyInfo where + type AttrAllowedOps WindowPropertiesStatusbarVisiblePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesStatusbarVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesStatusbarVisiblePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesStatusbarVisiblePropertyInfo = Bool + type AttrLabel WindowPropertiesStatusbarVisiblePropertyInfo = "statusbar-visible" + type AttrOrigin WindowPropertiesStatusbarVisiblePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesStatusbarVisible + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesStatusbarVisible + attrClear _ = undefined +#endif + +-- VVV Prop "toolbar-visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@toolbar-visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' windowProperties #toolbarVisible +@ +-} +getWindowPropertiesToolbarVisible :: (MonadIO m, IsWindowProperties o) => o -> m Bool +getWindowPropertiesToolbarVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "toolbar-visible" + +{- | +Construct a `GValueConstruct` with valid value for the “@toolbar-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructWindowPropertiesToolbarVisible :: (IsWindowProperties o) => Bool -> IO (GValueConstruct o) +constructWindowPropertiesToolbarVisible val = B.Properties.constructObjectPropertyBool "toolbar-visible" val + +#if ENABLE_OVERLOADING +data WindowPropertiesToolbarVisiblePropertyInfo +instance AttrInfo WindowPropertiesToolbarVisiblePropertyInfo where + type AttrAllowedOps WindowPropertiesToolbarVisiblePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint WindowPropertiesToolbarVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint WindowPropertiesToolbarVisiblePropertyInfo = IsWindowProperties + type AttrGetType WindowPropertiesToolbarVisiblePropertyInfo = Bool + type AttrLabel WindowPropertiesToolbarVisiblePropertyInfo = "toolbar-visible" + type AttrOrigin WindowPropertiesToolbarVisiblePropertyInfo = WindowProperties + attrGet _ = getWindowPropertiesToolbarVisible + attrSet _ = undefined + attrConstruct _ = constructWindowPropertiesToolbarVisible + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WindowProperties +type instance O.AttributeList WindowProperties = WindowPropertiesAttributeList +type WindowPropertiesAttributeList = ('[ '("fullscreen", WindowPropertiesFullscreenPropertyInfo), '("geometry", WindowPropertiesGeometryPropertyInfo), '("locationbarVisible", WindowPropertiesLocationbarVisiblePropertyInfo), '("menubarVisible", WindowPropertiesMenubarVisiblePropertyInfo), '("resizable", WindowPropertiesResizablePropertyInfo), '("scrollbarsVisible", WindowPropertiesScrollbarsVisiblePropertyInfo), '("statusbarVisible", WindowPropertiesStatusbarVisiblePropertyInfo), '("toolbarVisible", WindowPropertiesToolbarVisiblePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +windowPropertiesFullscreen :: AttrLabelProxy "fullscreen" +windowPropertiesFullscreen = AttrLabelProxy + +windowPropertiesGeometry :: AttrLabelProxy "geometry" +windowPropertiesGeometry = AttrLabelProxy + +windowPropertiesLocationbarVisible :: AttrLabelProxy "locationbarVisible" +windowPropertiesLocationbarVisible = AttrLabelProxy + +windowPropertiesMenubarVisible :: AttrLabelProxy "menubarVisible" +windowPropertiesMenubarVisible = AttrLabelProxy + +windowPropertiesResizable :: AttrLabelProxy "resizable" +windowPropertiesResizable = AttrLabelProxy + +windowPropertiesScrollbarsVisible :: AttrLabelProxy "scrollbarsVisible" +windowPropertiesScrollbarsVisible = AttrLabelProxy + +windowPropertiesStatusbarVisible :: AttrLabelProxy "statusbarVisible" +windowPropertiesStatusbarVisible = AttrLabelProxy + +windowPropertiesToolbarVisible :: AttrLabelProxy "toolbarVisible" +windowPropertiesToolbarVisible = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList WindowProperties = WindowPropertiesSignalList +type WindowPropertiesSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method WindowProperties::get_fullscreen +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_fullscreen" webkit_window_properties_get_fullscreen :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should be shown in fullscreen state or not. +-} +windowPropertiesGetFullscreen :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if the window should be fullscreen or 'False' otherwise. -} +windowPropertiesGetFullscreen windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_fullscreen windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetFullscreenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetFullscreenMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetFullscreen + +#endif + +-- method WindowProperties::get_geometry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "geometry", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the window geometry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_geometry" webkit_window_properties_get_geometry :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + Ptr Gdk.Rectangle.Rectangle -> -- geometry : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + IO () + +{- | +Get the geometry the window should have on the screen when shown. +-} +windowPropertiesGetGeometry :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m (Gdk.Rectangle.Rectangle) +windowPropertiesGetGeometry windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + geometry <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle) + webkit_window_properties_get_geometry windowProperties' geometry + geometry' <- (wrapBoxed Gdk.Rectangle.Rectangle) geometry + touchManagedPtr windowProperties + return geometry' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetGeometryMethodInfo +instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetGeometryMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetGeometry + +#endif + +-- method WindowProperties::get_locationbar_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_locationbar_visible" webkit_window_properties_get_locationbar_visible :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should have the locationbar visible or not. +-} +windowPropertiesGetLocationbarVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if locationbar should be visible or 'False' otherwise. -} +windowPropertiesGetLocationbarVisible windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_locationbar_visible windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetLocationbarVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetLocationbarVisibleMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetLocationbarVisible + +#endif + +-- method WindowProperties::get_menubar_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_menubar_visible" webkit_window_properties_get_menubar_visible :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should have the menubar visible or not. +-} +windowPropertiesGetMenubarVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if menubar should be visible or 'False' otherwise. -} +windowPropertiesGetMenubarVisible windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_menubar_visible windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetMenubarVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetMenubarVisibleMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetMenubarVisible + +#endif + +-- method WindowProperties::get_resizable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_resizable" webkit_window_properties_get_resizable :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should be resizable by the user or not. +-} +windowPropertiesGetResizable :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if the window should be resizable or 'False' otherwise. -} +windowPropertiesGetResizable windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_resizable windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetResizableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetResizableMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetResizable + +#endif + +-- method WindowProperties::get_scrollbars_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_scrollbars_visible" webkit_window_properties_get_scrollbars_visible :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should have the scrollbars visible or not. +-} +windowPropertiesGetScrollbarsVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if scrollbars should be visible or 'False' otherwise. -} +windowPropertiesGetScrollbarsVisible windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_scrollbars_visible windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetScrollbarsVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetScrollbarsVisibleMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetScrollbarsVisible + +#endif + +-- method WindowProperties::get_statusbar_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_statusbar_visible" webkit_window_properties_get_statusbar_visible :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should have the statusbar visible or not. +-} +windowPropertiesGetStatusbarVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if statusbar should be visible or 'False' otherwise. -} +windowPropertiesGetStatusbarVisible windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_statusbar_visible windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetStatusbarVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetStatusbarVisibleMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetStatusbarVisible + +#endif + +-- method WindowProperties::get_toolbar_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window_properties", argType = TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWindowProperties", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_window_properties_get_toolbar_visible" webkit_window_properties_get_toolbar_visible :: + Ptr WindowProperties -> -- window_properties : TInterface (Name {namespace = "WebKit2", name = "WindowProperties"}) + IO CInt + +{- | +Get whether the window should have the toolbar visible or not. +-} +windowPropertiesGetToolbarVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsWindowProperties a) => + a + {- ^ /@windowProperties@/: a 'GI.WebKit2.Objects.WindowProperties.WindowProperties' -} + -> m Bool + {- ^ __Returns:__ 'True' if toolbar should be visible or 'False' otherwise. -} +windowPropertiesGetToolbarVisible windowProperties = liftIO $ do + windowProperties' <- unsafeManagedPtrCastPtr windowProperties + result <- webkit_window_properties_get_toolbar_visible windowProperties' + let result' = (/= 0) result + touchManagedPtr windowProperties + return result' + +#if ENABLE_OVERLOADING +data WindowPropertiesGetToolbarVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsWindowProperties a) => O.MethodInfo WindowPropertiesGetToolbarVisibleMethodInfo a signature where + overloadedMethod _ = windowPropertiesGetToolbarVisible + +#endif + + diff --git a/GI/WebKit2/Objects/WindowProperties.hs-boot b/GI/WebKit2/Objects/WindowProperties.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Objects/WindowProperties.hs-boot @@ -0,0 +1,77 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Objects.WindowProperties 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 + +newtype WindowProperties = WindowProperties (ManagedPtr WindowProperties) +instance GObject WindowProperties where +class (GObject o, O.IsDescendantOf WindowProperties o) => IsWindowProperties o +instance (GObject o, O.IsDescendantOf WindowProperties o) => IsWindowProperties o +instance O.HasParentTypes WindowProperties +#if ENABLE_OVERLOADING +data WindowPropertiesFullscreenPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGeometryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesLocationbarVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesMenubarVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesResizablePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesScrollbarsVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesStatusbarVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesToolbarVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetFullscreenMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetGeometryMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetLocationbarVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetMenubarVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetResizableMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetScrollbarsVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetStatusbarVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data WindowPropertiesGetToolbarVisibleMethodInfo +#endif diff --git a/GI/WebKit2/Structs.hs b/GI/WebKit2/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs.hs @@ -0,0 +1,67 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.WebKit2.Structs + ( module GI.WebKit2.Structs.ApplicationInfo, + module GI.WebKit2.Structs.Credential , + module GI.WebKit2.Structs.JavascriptResult, + module GI.WebKit2.Structs.MimeInfo , + module GI.WebKit2.Structs.NavigationAction, + module GI.WebKit2.Structs.NetworkProxySettings, + module GI.WebKit2.Structs.OptionMenuItem, + module GI.WebKit2.Structs.ScriptDialog , + module GI.WebKit2.Structs.SecurityOrigin, + module GI.WebKit2.Structs.UserContentFilter, + module GI.WebKit2.Structs.UserScript , + module GI.WebKit2.Structs.UserStyleSheet, + module GI.WebKit2.Structs.WebViewSessionState, + module GI.WebKit2.Structs.WebsiteData , + + + ) where + +import GI.WebKit2.Structs.ApplicationInfo +import GI.WebKit2.Structs.Credential +import GI.WebKit2.Structs.JavascriptResult +import GI.WebKit2.Structs.MimeInfo +import GI.WebKit2.Structs.NavigationAction +import GI.WebKit2.Structs.NetworkProxySettings +import GI.WebKit2.Structs.OptionMenuItem +import GI.WebKit2.Structs.ScriptDialog +import GI.WebKit2.Structs.SecurityOrigin +import GI.WebKit2.Structs.UserContentFilter +import GI.WebKit2.Structs.UserScript +import GI.WebKit2.Structs.UserStyleSheet +import GI.WebKit2.Structs.WebViewSessionState +import GI.WebKit2.Structs.WebsiteData + +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 + + + diff --git a/GI/WebKit2/Structs/ApplicationInfo.hs b/GI/WebKit2/Structs/ApplicationInfo.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/ApplicationInfo.hs @@ -0,0 +1,419 @@ + + +{- | +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.Structs.ApplicationInfo + ( + +-- * Exported types + ApplicationInfo(..) , + noApplicationInfo , + + + -- * Methods +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + ApplicationInfoGetNameMethodInfo , +#endif + applicationInfoGetName , + + +-- ** getVersion #method:getVersion# + +#if ENABLE_OVERLOADING + ApplicationInfoGetVersionMethodInfo , +#endif + applicationInfoGetVersion , + + +-- ** new #method:new# + + applicationInfoNew , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + ApplicationInfoRefMethodInfo , +#endif + applicationInfoRef , + + +-- ** setName #method:setName# + +#if ENABLE_OVERLOADING + ApplicationInfoSetNameMethodInfo , +#endif + applicationInfoSetName , + + +-- ** setVersion #method:setVersion# + +#if ENABLE_OVERLOADING + ApplicationInfoSetVersionMethodInfo , +#endif + applicationInfoSetVersion , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + ApplicationInfoUnrefMethodInfo , +#endif + applicationInfoUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype ApplicationInfo = ApplicationInfo (ManagedPtr ApplicationInfo) +foreign import ccall "webkit_application_info_get_type" c_webkit_application_info_get_type :: + IO GType + +instance BoxedObject ApplicationInfo where + boxedType _ = c_webkit_application_info_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `ApplicationInfo`. +noApplicationInfo :: Maybe ApplicationInfo +noApplicationInfo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ApplicationInfo +type instance O.AttributeList ApplicationInfo = ApplicationInfoAttributeList +type ApplicationInfoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method ApplicationInfo::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_new" webkit_application_info_new :: + IO (Ptr ApplicationInfo) + +{- | +Creates a new 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' + +/Since: 2.18/ +-} +applicationInfoNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m ApplicationInfo + {- ^ __Returns:__ the newly created 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo'. -} +applicationInfoNew = liftIO $ do + result <- webkit_application_info_new + checkUnexpectedReturnNULL "applicationInfoNew" result + result' <- (wrapBoxed ApplicationInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ApplicationInfo::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", 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_application_info_get_name" webkit_application_info_get_name :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + IO CString + +{- | +Get the name of the application. If 'GI.WebKit2.Structs.ApplicationInfo.applicationInfoSetName' hasn\'t been +called with a valid name, this returns 'GI.GLib.Functions.getPrgname'. + +/Since: 2.18/ +-} +applicationInfoGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> m T.Text + {- ^ __Returns:__ the application name -} +applicationInfoGetName info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_application_info_get_name info' + checkUnexpectedReturnNULL "applicationInfoGetName" result + result' <- cstringToText result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data ApplicationInfoGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ApplicationInfoGetNameMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoGetName + +#endif + +-- method ApplicationInfo::get_version +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "major", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the major version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minor", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the minor version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "micro", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the micro version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_get_version" webkit_application_info_get_version :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + Ptr Word64 -> -- major : TBasicType TUInt64 + Ptr Word64 -> -- minor : TBasicType TUInt64 + Ptr Word64 -> -- micro : TBasicType TUInt64 + IO () + +{- | +Get the application version previously set with 'GI.WebKit2.Structs.ApplicationInfo.applicationInfoSetVersion'. + +/Since: 2.18/ +-} +applicationInfoGetVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> m ((Word64, Word64, Word64)) +applicationInfoGetVersion info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + major <- allocMem :: IO (Ptr Word64) + minor <- allocMem :: IO (Ptr Word64) + micro <- allocMem :: IO (Ptr Word64) + webkit_application_info_get_version info' major minor micro + major' <- peek major + minor' <- peek minor + micro' <- peek micro + touchManagedPtr info + freeMem major + freeMem minor + freeMem micro + return (major', minor', micro') + +#if ENABLE_OVERLOADING +data ApplicationInfoGetVersionMethodInfo +instance (signature ~ (m ((Word64, Word64, Word64))), MonadIO m) => O.MethodInfo ApplicationInfoGetVersionMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoGetVersion + +#endif + +-- method ApplicationInfo::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_ref" webkit_application_info_ref :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + IO (Ptr ApplicationInfo) + +{- | +Atomically increments the reference count of /@info@/ by one. This +function is MT-safe and may be called from any thread. + +/Since: 2.18/ +-} +applicationInfoRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> m ApplicationInfo + {- ^ __Returns:__ The passed in 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} +applicationInfoRef info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_application_info_ref info' + checkUnexpectedReturnNULL "applicationInfoRef" result + result' <- (wrapBoxed ApplicationInfo) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data ApplicationInfoRefMethodInfo +instance (signature ~ (m ApplicationInfo), MonadIO m) => O.MethodInfo ApplicationInfoRefMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoRef + +#endif + +-- method ApplicationInfo::set_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the application name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_set_name" webkit_application_info_set_name :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + CString -> -- name : TBasicType TUTF8 + IO () + +{- | +Set the name of the application. If not provided, or 'Nothing' is passed, +'GI.GLib.Functions.getPrgname' will be used. + +/Since: 2.18/ +-} +applicationInfoSetName :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> T.Text + {- ^ /@name@/: the application name -} + -> m () +applicationInfoSetName info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + webkit_application_info_set_name info' name' + touchManagedPtr info + freeMem name' + return () + +#if ENABLE_OVERLOADING +data ApplicationInfoSetNameMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo ApplicationInfoSetNameMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoSetName + +#endif + +-- method ApplicationInfo::set_version +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "major", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the major version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minor", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minor version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "micro", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the micro version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_set_version" webkit_application_info_set_version :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + Word64 -> -- major : TBasicType TUInt64 + Word64 -> -- minor : TBasicType TUInt64 + Word64 -> -- micro : TBasicType TUInt64 + IO () + +{- | +Set the application version. If the application doesn\'t use the format +major.minor.micro you can pass 0 as the micro to use major.minor, or pass +0 as both micro and minor to use only major number. Any other format must +be converted to major.minor.micro so that it can be used in version comparisons. + +/Since: 2.18/ +-} +applicationInfoSetVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> Word64 + {- ^ /@major@/: the major version number -} + -> Word64 + {- ^ /@minor@/: the minor version number -} + -> Word64 + {- ^ /@micro@/: the micro version number -} + -> m () +applicationInfoSetVersion info major minor micro = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + webkit_application_info_set_version info' major minor micro + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data ApplicationInfoSetVersionMethodInfo +instance (signature ~ (Word64 -> Word64 -> Word64 -> m ()), MonadIO m) => O.MethodInfo ApplicationInfoSetVersionMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoSetVersion + +#endif + +-- method ApplicationInfo::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitApplicationInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_application_info_unref" webkit_application_info_unref :: + Ptr ApplicationInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "ApplicationInfo"}) + IO () + +{- | +Atomically decrements the reference count of /@info@/ by one. If the +reference count drops to 0, all memory allocated by the 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' is +released. This function is MT-safe and may be called from any +thread. + +/Since: 2.18/ +-} +applicationInfoUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ApplicationInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.ApplicationInfo.ApplicationInfo' -} + -> m () +applicationInfoUnref info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + webkit_application_info_unref info' + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data ApplicationInfoUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ApplicationInfoUnrefMethodInfo ApplicationInfo signature where + overloadedMethod _ = applicationInfoUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveApplicationInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveApplicationInfoMethod "ref" o = ApplicationInfoRefMethodInfo + ResolveApplicationInfoMethod "unref" o = ApplicationInfoUnrefMethodInfo + ResolveApplicationInfoMethod "getName" o = ApplicationInfoGetNameMethodInfo + ResolveApplicationInfoMethod "getVersion" o = ApplicationInfoGetVersionMethodInfo + ResolveApplicationInfoMethod "setName" o = ApplicationInfoSetNameMethodInfo + ResolveApplicationInfoMethod "setVersion" o = ApplicationInfoSetVersionMethodInfo + ResolveApplicationInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveApplicationInfoMethod t ApplicationInfo, O.MethodInfo info ApplicationInfo p) => OL.IsLabel t (ApplicationInfo -> 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 + + diff --git a/GI/WebKit2/Structs/ApplicationInfo.hs-boot b/GI/WebKit2/Structs/ApplicationInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/ApplicationInfo.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.ApplicationInfo 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 + +newtype ApplicationInfo = ApplicationInfo (ManagedPtr ApplicationInfo) +instance BoxedObject ApplicationInfo where +#if ENABLE_OVERLOADING +data ApplicationInfoGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ApplicationInfoGetVersionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ApplicationInfoRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ApplicationInfoSetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data ApplicationInfoSetVersionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ApplicationInfoUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/Credential.hs b/GI/WebKit2/Structs/Credential.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/Credential.hs @@ -0,0 +1,406 @@ + + +{- | +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.Structs.Credential + ( + +-- * Exported types + Credential(..) , + noCredential , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + CredentialCopyMethodInfo , +#endif + credentialCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + CredentialFreeMethodInfo , +#endif + credentialFree , + + +-- ** getPassword #method:getPassword# + +#if ENABLE_OVERLOADING + CredentialGetPasswordMethodInfo , +#endif + credentialGetPassword , + + +-- ** getPersistence #method:getPersistence# + +#if ENABLE_OVERLOADING + CredentialGetPersistenceMethodInfo , +#endif + credentialGetPersistence , + + +-- ** getUsername #method:getUsername# + +#if ENABLE_OVERLOADING + CredentialGetUsernameMethodInfo , +#endif + credentialGetUsername , + + +-- ** hasPassword #method:hasPassword# + +#if ENABLE_OVERLOADING + CredentialHasPasswordMethodInfo , +#endif + credentialHasPassword , + + +-- ** new #method:new# + + credentialNew , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype Credential = Credential (ManagedPtr Credential) +foreign import ccall "webkit_credential_get_type" c_webkit_credential_get_type :: + IO GType + +instance BoxedObject Credential where + boxedType _ = c_webkit_credential_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Credential`. +noCredential :: Maybe Credential +noCredential = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Credential +type instance O.AttributeList Credential = CredentialAttributeList +type CredentialAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Credential::new +-- method type : Constructor +-- Args : [Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The username for the new credential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The password for the new credential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "persistence", argType = TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #WebKitCredentialPersistence of the new credential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Credential"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_credential_new" webkit_credential_new :: + CString -> -- username : TBasicType TUTF8 + CString -> -- password : TBasicType TUTF8 + CUInt -> -- persistence : TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"}) + IO (Ptr Credential) + +{- | +Create a new credential from the provided username, password and persistence mode. + +/Since: 2.2/ +-} +credentialNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@username@/: The username for the new credential -} + -> T.Text + {- ^ /@password@/: The password for the new credential -} + -> WebKit2.Enums.CredentialPersistence + {- ^ /@persistence@/: The 'GI.WebKit2.Enums.CredentialPersistence' of the new credential -} + -> m Credential + {- ^ __Returns:__ A 'GI.WebKit2.Structs.Credential.Credential'. -} +credentialNew username password persistence = liftIO $ do + username' <- textToCString username + password' <- textToCString password + let persistence' = (fromIntegral . fromEnum) persistence + result <- webkit_credential_new username' password' persistence' + checkUnexpectedReturnNULL "credentialNew" result + result' <- (wrapBoxed Credential) result + freeMem username' + freeMem password' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Credential::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCredential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Credential"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_credential_copy" webkit_credential_copy :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO (Ptr Credential) + +{- | +Make a copy of the 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +credentialCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: a 'GI.WebKit2.Structs.Credential.Credential' -} + -> m Credential + {- ^ __Returns:__ A copy of passed in 'GI.WebKit2.Structs.Credential.Credential' -} +credentialCopy credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + result <- webkit_credential_copy credential' + checkUnexpectedReturnNULL "credentialCopy" result + result' <- (wrapBoxed Credential) result + touchManagedPtr credential + return result' + +#if ENABLE_OVERLOADING +data CredentialCopyMethodInfo +instance (signature ~ (m Credential), MonadIO m) => O.MethodInfo CredentialCopyMethodInfo Credential signature where + overloadedMethod _ = credentialCopy + +#endif + +-- method Credential::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitCredential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_credential_free" webkit_credential_free :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO () + +{- | +Free the 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +credentialFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: A 'GI.WebKit2.Structs.Credential.Credential' -} + -> m () +credentialFree credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + webkit_credential_free credential' + touchManagedPtr credential + return () + +#if ENABLE_OVERLOADING +data CredentialFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo CredentialFreeMethodInfo Credential signature where + overloadedMethod _ = credentialFree + +#endif + +-- method Credential::get_password +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCredential", 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_credential_get_password" webkit_credential_get_password :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO CString + +{- | +Get the password currently held by this 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +credentialGetPassword :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: a 'GI.WebKit2.Structs.Credential.Credential' -} + -> m T.Text + {- ^ __Returns:__ The password stored in the 'GI.WebKit2.Structs.Credential.Credential'. -} +credentialGetPassword credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + result <- webkit_credential_get_password credential' + checkUnexpectedReturnNULL "credentialGetPassword" result + result' <- cstringToText result + touchManagedPtr credential + return result' + +#if ENABLE_OVERLOADING +data CredentialGetPasswordMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredentialGetPasswordMethodInfo Credential signature where + overloadedMethod _ = credentialGetPassword + +#endif + +-- method Credential::get_persistence +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCredential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CredentialPersistence"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_credential_get_persistence" webkit_credential_get_persistence :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO CUInt + +{- | +Get the persistence mode currently held by this 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +credentialGetPersistence :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: a 'GI.WebKit2.Structs.Credential.Credential' -} + -> m WebKit2.Enums.CredentialPersistence + {- ^ __Returns:__ The 'GI.WebKit2.Enums.CredentialPersistence' stored in the 'GI.WebKit2.Structs.Credential.Credential'. -} +credentialGetPersistence credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + result <- webkit_credential_get_persistence credential' + let result' = (toEnum . fromIntegral) result + touchManagedPtr credential + return result' + +#if ENABLE_OVERLOADING +data CredentialGetPersistenceMethodInfo +instance (signature ~ (m WebKit2.Enums.CredentialPersistence), MonadIO m) => O.MethodInfo CredentialGetPersistenceMethodInfo Credential signature where + overloadedMethod _ = credentialGetPersistence + +#endif + +-- method Credential::get_username +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCredential", 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_credential_get_username" webkit_credential_get_username :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO CString + +{- | +Get the username currently held by this 'GI.WebKit2.Structs.Credential.Credential'. + +/Since: 2.2/ +-} +credentialGetUsername :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: a 'GI.WebKit2.Structs.Credential.Credential' -} + -> m T.Text + {- ^ __Returns:__ The username stored in the 'GI.WebKit2.Structs.Credential.Credential'. -} +credentialGetUsername credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + result <- webkit_credential_get_username credential' + checkUnexpectedReturnNULL "credentialGetUsername" result + result' <- cstringToText result + touchManagedPtr credential + return result' + +#if ENABLE_OVERLOADING +data CredentialGetUsernameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CredentialGetUsernameMethodInfo Credential signature where + overloadedMethod _ = credentialGetUsername + +#endif + +-- method Credential::has_password +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "credential", argType = TInterface (Name {namespace = "WebKit2", name = "Credential"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCredential", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_credential_has_password" webkit_credential_has_password :: + Ptr Credential -> -- credential : TInterface (Name {namespace = "WebKit2", name = "Credential"}) + IO CInt + +{- | +Determine whether this credential has a password stored. + +/Since: 2.2/ +-} +credentialHasPassword :: + (B.CallStack.HasCallStack, MonadIO m) => + Credential + {- ^ /@credential@/: a 'GI.WebKit2.Structs.Credential.Credential' -} + -> m Bool + {- ^ __Returns:__ 'True' if the credential has a password or 'False' otherwise. -} +credentialHasPassword credential = liftIO $ do + credential' <- unsafeManagedPtrGetPtr credential + result <- webkit_credential_has_password credential' + let result' = (/= 0) result + touchManagedPtr credential + return result' + +#if ENABLE_OVERLOADING +data CredentialHasPasswordMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo CredentialHasPasswordMethodInfo Credential signature where + overloadedMethod _ = credentialHasPassword + +#endif + +#if ENABLE_OVERLOADING +type family ResolveCredentialMethod (t :: Symbol) (o :: *) :: * where + ResolveCredentialMethod "copy" o = CredentialCopyMethodInfo + ResolveCredentialMethod "free" o = CredentialFreeMethodInfo + ResolveCredentialMethod "hasPassword" o = CredentialHasPasswordMethodInfo + ResolveCredentialMethod "getPassword" o = CredentialGetPasswordMethodInfo + ResolveCredentialMethod "getPersistence" o = CredentialGetPersistenceMethodInfo + ResolveCredentialMethod "getUsername" o = CredentialGetUsernameMethodInfo + ResolveCredentialMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCredentialMethod t Credential, O.MethodInfo info Credential p) => OL.IsLabel t (Credential -> 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 + + diff --git a/GI/WebKit2/Structs/Credential.hs-boot b/GI/WebKit2/Structs/Credential.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/Credential.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.Credential 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 + +newtype Credential = Credential (ManagedPtr Credential) +instance BoxedObject Credential where +#if ENABLE_OVERLOADING +data CredentialCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredentialFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredentialGetPasswordMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredentialGetPersistenceMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredentialGetUsernameMethodInfo +#endif +#if ENABLE_OVERLOADING +data CredentialHasPasswordMethodInfo +#endif diff --git a/GI/WebKit2/Structs/JavascriptResult.hs b/GI/WebKit2/Structs/JavascriptResult.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/JavascriptResult.hs @@ -0,0 +1,219 @@ + + +{- | +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.Structs.JavascriptResult + ( + +-- * Exported types + JavascriptResult(..) , + noJavascriptResult , + + + -- * Methods +-- ** getJsValue #method:getJsValue# + +#if ENABLE_OVERLOADING + JavascriptResultGetJsValueMethodInfo , +#endif + javascriptResultGetJsValue , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + JavascriptResultRefMethodInfo , +#endif + javascriptResultRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + JavascriptResultUnrefMethodInfo , +#endif + javascriptResultUnref , + + + + + ) 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.JavaScriptCore.Objects.Value as JavaScriptCore.Value + +-- | Memory-managed wrapper type. +newtype JavascriptResult = JavascriptResult (ManagedPtr JavascriptResult) +foreign import ccall "webkit_javascript_result_get_type" c_webkit_javascript_result_get_type :: + IO GType + +instance BoxedObject JavascriptResult where + boxedType _ = c_webkit_javascript_result_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `JavascriptResult`. +noJavascriptResult :: Maybe JavascriptResult +noJavascriptResult = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList JavascriptResult +type instance O.AttributeList JavascriptResult = JavascriptResultAttributeList +type JavascriptResultAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method JavascriptResult::get_js_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "js_result", argType = TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitJavascriptResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_javascript_result_get_js_value" webkit_javascript_result_get_js_value :: + Ptr JavascriptResult -> -- js_result : TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}) + IO (Ptr JavaScriptCore.Value.Value) + +{- | +Get the 'GI.JavaScriptCore.Objects.Value.Value' of /@jsResult@/. + +/Since: 2.22/ +-} +javascriptResultGetJsValue :: + (B.CallStack.HasCallStack, MonadIO m) => + JavascriptResult + {- ^ /@jsResult@/: a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' -} + -> m JavaScriptCore.Value.Value + {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.Value.Value' of the 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' -} +javascriptResultGetJsValue jsResult = liftIO $ do + jsResult' <- unsafeManagedPtrGetPtr jsResult + result <- webkit_javascript_result_get_js_value jsResult' + checkUnexpectedReturnNULL "javascriptResultGetJsValue" result + result' <- (newObject JavaScriptCore.Value.Value) result + touchManagedPtr jsResult + return result' + +#if ENABLE_OVERLOADING +data JavascriptResultGetJsValueMethodInfo +instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m) => O.MethodInfo JavascriptResultGetJsValueMethodInfo JavascriptResult signature where + overloadedMethod _ = javascriptResultGetJsValue + +#endif + +-- method JavascriptResult::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "js_result", argType = TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitJavascriptResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_javascript_result_ref" webkit_javascript_result_ref :: + Ptr JavascriptResult -> -- js_result : TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}) + IO (Ptr JavascriptResult) + +{- | +Atomically increments the reference count of /@jsResult@/ by one. This +function is MT-safe and may be called from any thread. +-} +javascriptResultRef :: + (B.CallStack.HasCallStack, MonadIO m) => + JavascriptResult + {- ^ /@jsResult@/: a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' -} + -> m JavascriptResult + {- ^ __Returns:__ The passed in 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' -} +javascriptResultRef jsResult = liftIO $ do + jsResult' <- unsafeManagedPtrGetPtr jsResult + result <- webkit_javascript_result_ref jsResult' + checkUnexpectedReturnNULL "javascriptResultRef" result + result' <- (wrapBoxed JavascriptResult) result + touchManagedPtr jsResult + return result' + +#if ENABLE_OVERLOADING +data JavascriptResultRefMethodInfo +instance (signature ~ (m JavascriptResult), MonadIO m) => O.MethodInfo JavascriptResultRefMethodInfo JavascriptResult signature where + overloadedMethod _ = javascriptResultRef + +#endif + +-- method JavascriptResult::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "js_result", argType = TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitJavascriptResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_javascript_result_unref" webkit_javascript_result_unref :: + Ptr JavascriptResult -> -- js_result : TInterface (Name {namespace = "WebKit2", name = "JavascriptResult"}) + IO () + +{- | +Atomically decrements the reference count of /@jsResult@/ by one. If the +reference count drops to 0, all memory allocated by the 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' is +released. This function is MT-safe and may be called from any +thread. +-} +javascriptResultUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + JavascriptResult + {- ^ /@jsResult@/: a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' -} + -> m () +javascriptResultUnref jsResult = liftIO $ do + jsResult' <- unsafeManagedPtrGetPtr jsResult + webkit_javascript_result_unref jsResult' + touchManagedPtr jsResult + return () + +#if ENABLE_OVERLOADING +data JavascriptResultUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo JavascriptResultUnrefMethodInfo JavascriptResult signature where + overloadedMethod _ = javascriptResultUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveJavascriptResultMethod (t :: Symbol) (o :: *) :: * where + ResolveJavascriptResultMethod "ref" o = JavascriptResultRefMethodInfo + ResolveJavascriptResultMethod "unref" o = JavascriptResultUnrefMethodInfo + ResolveJavascriptResultMethod "getJsValue" o = JavascriptResultGetJsValueMethodInfo + ResolveJavascriptResultMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveJavascriptResultMethod t JavascriptResult, O.MethodInfo info JavascriptResult p) => OL.IsLabel t (JavascriptResult -> 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 + + diff --git a/GI/WebKit2/Structs/JavascriptResult.hs-boot b/GI/WebKit2/Structs/JavascriptResult.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/JavascriptResult.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.JavascriptResult 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 + +newtype JavascriptResult = JavascriptResult (ManagedPtr JavascriptResult) +instance BoxedObject JavascriptResult where +#if ENABLE_OVERLOADING +data JavascriptResultGetJsValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data JavascriptResultRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data JavascriptResultUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/MimeInfo.hs b/GI/WebKit2/Structs/MimeInfo.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/MimeInfo.hs @@ -0,0 +1,308 @@ + + +{- | +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.Structs.MimeInfo + ( + +-- * Exported types + MimeInfo(..) , + noMimeInfo , + + + -- * Methods +-- ** getDescription #method:getDescription# + +#if ENABLE_OVERLOADING + MimeInfoGetDescriptionMethodInfo , +#endif + mimeInfoGetDescription , + + +-- ** getExtensions #method:getExtensions# + +#if ENABLE_OVERLOADING + MimeInfoGetExtensionsMethodInfo , +#endif + mimeInfoGetExtensions , + + +-- ** getMimeType #method:getMimeType# + +#if ENABLE_OVERLOADING + MimeInfoGetMimeTypeMethodInfo , +#endif + mimeInfoGetMimeType , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + MimeInfoRefMethodInfo , +#endif + mimeInfoRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + MimeInfoUnrefMethodInfo , +#endif + mimeInfoUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype MimeInfo = MimeInfo (ManagedPtr MimeInfo) +foreign import ccall "webkit_mime_info_get_type" c_webkit_mime_info_get_type :: + IO GType + +instance BoxedObject MimeInfo where + boxedType _ = c_webkit_mime_info_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `MimeInfo`. +noMimeInfo :: Maybe MimeInfo +noMimeInfo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList MimeInfo +type instance O.AttributeList MimeInfo = MimeInfoAttributeList +type MimeInfoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method MimeInfo::get_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitMimeInfo", 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_mime_info_get_description" webkit_mime_info_get_description :: + Ptr MimeInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +mimeInfoGetDescription :: + (B.CallStack.HasCallStack, MonadIO m) => + MimeInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} + -> m T.Text + {- ^ __Returns:__ the description of the MIME type of /@info@/ -} +mimeInfoGetDescription info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_mime_info_get_description info' + checkUnexpectedReturnNULL "mimeInfoGetDescription" result + result' <- cstringToText result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data MimeInfoGetDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo MimeInfoGetDescriptionMethodInfo MimeInfo signature where + overloadedMethod _ = mimeInfoGetDescription + +#endif + +-- method MimeInfo::get_extensions +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitMimeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_mime_info_get_extensions" webkit_mime_info_get_extensions :: + Ptr MimeInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}) + IO (Ptr CString) + +{- | +Get the list of file extensions associated to the +MIME type of /@info@/ +-} +mimeInfoGetExtensions :: + (B.CallStack.HasCallStack, MonadIO m) => + MimeInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} + -> m [T.Text] + {- ^ __Returns:__ a + 'Nothing'-terminated array of strings -} +mimeInfoGetExtensions info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_mime_info_get_extensions info' + checkUnexpectedReturnNULL "mimeInfoGetExtensions" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data MimeInfoGetExtensionsMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m) => O.MethodInfo MimeInfoGetExtensionsMethodInfo MimeInfo signature where + overloadedMethod _ = mimeInfoGetExtensions + +#endif + +-- method MimeInfo::get_mime_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitMimeInfo", 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_mime_info_get_mime_type" webkit_mime_info_get_mime_type :: + Ptr MimeInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +mimeInfoGetMimeType :: + (B.CallStack.HasCallStack, MonadIO m) => + MimeInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} + -> m T.Text + {- ^ __Returns:__ the MIME type of /@info@/ -} +mimeInfoGetMimeType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_mime_info_get_mime_type info' + checkUnexpectedReturnNULL "mimeInfoGetMimeType" result + result' <- cstringToText result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data MimeInfoGetMimeTypeMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo MimeInfoGetMimeTypeMethodInfo MimeInfo signature where + overloadedMethod _ = mimeInfoGetMimeType + +#endif + +-- method MimeInfo::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitMimeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "MimeInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_mime_info_ref" webkit_mime_info_ref :: + Ptr MimeInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}) + IO (Ptr MimeInfo) + +{- | +Atomically increments the reference count of /@info@/ by one. This +function is MT-safe and may be called from any thread. +-} +mimeInfoRef :: + (B.CallStack.HasCallStack, MonadIO m) => + MimeInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} + -> m MimeInfo + {- ^ __Returns:__ The passed in 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} +mimeInfoRef info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- webkit_mime_info_ref info' + checkUnexpectedReturnNULL "mimeInfoRef" result + result' <- (wrapBoxed MimeInfo) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data MimeInfoRefMethodInfo +instance (signature ~ (m MimeInfo), MonadIO m) => O.MethodInfo MimeInfoRefMethodInfo MimeInfo signature where + overloadedMethod _ = mimeInfoRef + +#endif + +-- method MimeInfo::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitMimeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_mime_info_unref" webkit_mime_info_unref :: + Ptr MimeInfo -> -- info : TInterface (Name {namespace = "WebKit2", name = "MimeInfo"}) + IO () + +{- | +Atomically decrements the reference count of /@info@/ by one. If the +reference count drops to 0, all memory allocated by the 'GI.WebKit2.Structs.MimeInfo.MimeInfo' is +released. This function is MT-safe and may be called from any +thread. +-} +mimeInfoUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + MimeInfo + {- ^ /@info@/: a 'GI.WebKit2.Structs.MimeInfo.MimeInfo' -} + -> m () +mimeInfoUnref info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + webkit_mime_info_unref info' + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data MimeInfoUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MimeInfoUnrefMethodInfo MimeInfo signature where + overloadedMethod _ = mimeInfoUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveMimeInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveMimeInfoMethod "ref" o = MimeInfoRefMethodInfo + ResolveMimeInfoMethod "unref" o = MimeInfoUnrefMethodInfo + ResolveMimeInfoMethod "getDescription" o = MimeInfoGetDescriptionMethodInfo + ResolveMimeInfoMethod "getExtensions" o = MimeInfoGetExtensionsMethodInfo + ResolveMimeInfoMethod "getMimeType" o = MimeInfoGetMimeTypeMethodInfo + ResolveMimeInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMimeInfoMethod t MimeInfo, O.MethodInfo info MimeInfo p) => OL.IsLabel t (MimeInfo -> 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 + + diff --git a/GI/WebKit2/Structs/MimeInfo.hs-boot b/GI/WebKit2/Structs/MimeInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/MimeInfo.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.MimeInfo 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 + +newtype MimeInfo = MimeInfo (ManagedPtr MimeInfo) +instance BoxedObject MimeInfo where +#if ENABLE_OVERLOADING +data MimeInfoGetDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data MimeInfoGetExtensionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data MimeInfoGetMimeTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data MimeInfoRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data MimeInfoUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/NavigationAction.hs b/GI/WebKit2/Structs/NavigationAction.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/NavigationAction.hs @@ -0,0 +1,455 @@ + + +{- | +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.Structs.NavigationAction + ( + +-- * Exported types + NavigationAction(..) , + noNavigationAction , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + NavigationActionCopyMethodInfo , +#endif + navigationActionCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + NavigationActionFreeMethodInfo , +#endif + navigationActionFree , + + +-- ** getModifiers #method:getModifiers# + +#if ENABLE_OVERLOADING + NavigationActionGetModifiersMethodInfo , +#endif + navigationActionGetModifiers , + + +-- ** getMouseButton #method:getMouseButton# + +#if ENABLE_OVERLOADING + NavigationActionGetMouseButtonMethodInfo, +#endif + navigationActionGetMouseButton , + + +-- ** getNavigationType #method:getNavigationType# + +#if ENABLE_OVERLOADING + NavigationActionGetNavigationTypeMethodInfo, +#endif + navigationActionGetNavigationType , + + +-- ** getRequest #method:getRequest# + +#if ENABLE_OVERLOADING + NavigationActionGetRequestMethodInfo , +#endif + navigationActionGetRequest , + + +-- ** isRedirect #method:isRedirect# + +#if ENABLE_OVERLOADING + NavigationActionIsRedirectMethodInfo , +#endif + navigationActionIsRedirect , + + +-- ** isUserGesture #method:isUserGesture# + +#if ENABLE_OVERLOADING + NavigationActionIsUserGestureMethodInfo , +#endif + navigationActionIsUserGesture , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums +import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest + +-- | Memory-managed wrapper type. +newtype NavigationAction = NavigationAction (ManagedPtr NavigationAction) +foreign import ccall "webkit_navigation_action_get_type" c_webkit_navigation_action_get_type :: + IO GType + +instance BoxedObject NavigationAction where + boxedType _ = c_webkit_navigation_action_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `NavigationAction`. +noNavigationAction :: Maybe NavigationAction +noNavigationAction = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList NavigationAction +type instance O.AttributeList NavigationAction = NavigationActionAttributeList +type NavigationActionAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method NavigationAction::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NavigationAction"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_copy" webkit_navigation_action_copy :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO (Ptr NavigationAction) + +{- | +Make a copy of /@navigation@/. + +/Since: 2.6/ +-} +navigationActionCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m NavigationAction + {- ^ __Returns:__ A copy of passed in 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} +navigationActionCopy navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_copy navigation' + checkUnexpectedReturnNULL "navigationActionCopy" result + result' <- (wrapBoxed NavigationAction) result + touchManagedPtr navigation + return result' + +#if ENABLE_OVERLOADING +data NavigationActionCopyMethodInfo +instance (signature ~ (m NavigationAction), MonadIO m) => O.MethodInfo NavigationActionCopyMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionCopy + +#endif + +-- method NavigationAction::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_free" webkit_navigation_action_free :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO () + +{- | +Free the 'GI.WebKit2.Structs.NavigationAction.NavigationAction' + +/Since: 2.6/ +-} +navigationActionFree :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m () +navigationActionFree navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + webkit_navigation_action_free navigation' + touchManagedPtr navigation + return () + +#if ENABLE_OVERLOADING +data NavigationActionFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NavigationActionFreeMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionFree + +#endif + +-- method NavigationAction::get_modifiers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_get_modifiers" webkit_navigation_action_get_modifiers :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO Word32 + +{- | +Return a bitmask of 'GI.Gdk.Flags.ModifierType' values describing the modifier keys that were in effect +when the navigation was requested + +/Since: 2.6/ +-} +navigationActionGetModifiers :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m Word32 + {- ^ __Returns:__ the modifier keys -} +navigationActionGetModifiers navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_get_modifiers navigation' + touchManagedPtr navigation + return result + +#if ENABLE_OVERLOADING +data NavigationActionGetModifiersMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NavigationActionGetModifiersMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionGetModifiers + +#endif + +-- method NavigationAction::get_mouse_button +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_get_mouse_button" webkit_navigation_action_get_mouse_button :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO Word32 + +{- | +Return the number of the mouse button that triggered the navigation, or 0 if +the navigation was not started by a mouse event. + +/Since: 2.6/ +-} +navigationActionGetMouseButton :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m Word32 + {- ^ __Returns:__ the mouse button number or 0 -} +navigationActionGetMouseButton navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_get_mouse_button navigation' + touchManagedPtr navigation + return result + +#if ENABLE_OVERLOADING +data NavigationActionGetMouseButtonMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NavigationActionGetMouseButtonMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionGetMouseButton + +#endif + +-- method NavigationAction::get_navigation_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NavigationType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_get_navigation_type" webkit_navigation_action_get_navigation_type :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO CUInt + +{- | +Return the type of action that triggered the navigation. + +/Since: 2.6/ +-} +navigationActionGetNavigationType :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m WebKit2.Enums.NavigationType + {- ^ __Returns:__ a 'GI.WebKit2.Enums.NavigationType' -} +navigationActionGetNavigationType navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_get_navigation_type navigation' + let result' = (toEnum . fromIntegral) result + touchManagedPtr navigation + return result' + +#if ENABLE_OVERLOADING +data NavigationActionGetNavigationTypeMethodInfo +instance (signature ~ (m WebKit2.Enums.NavigationType), MonadIO m) => O.MethodInfo NavigationActionGetNavigationTypeMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionGetNavigationType + +#endif + +-- method NavigationAction::get_request +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIRequest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_get_request" webkit_navigation_action_get_request :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO (Ptr WebKit2.URIRequest.URIRequest) + +{- | +Return the 'GI.WebKit2.Objects.URIRequest.URIRequest' associated with the navigation action. +Modifications to the returned object are \not\<\/emphasis> taken +into account when the request is sent over the network, and is intended +only to aid in evaluating whether a navigation action should be taken or +not. To modify requests before they are sent over the network the +@/WebKitPage::send-request/@ signal can be used instead. + +/Since: 2.6/ +-} +navigationActionGetRequest :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m WebKit2.URIRequest.URIRequest + {- ^ __Returns:__ a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} +navigationActionGetRequest navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_get_request navigation' + checkUnexpectedReturnNULL "navigationActionGetRequest" result + result' <- (newObject WebKit2.URIRequest.URIRequest) result + touchManagedPtr navigation + return result' + +#if ENABLE_OVERLOADING +data NavigationActionGetRequestMethodInfo +instance (signature ~ (m WebKit2.URIRequest.URIRequest), MonadIO m) => O.MethodInfo NavigationActionGetRequestMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionGetRequest + +#endif + +-- method NavigationAction::is_redirect +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_is_redirect" webkit_navigation_action_is_redirect :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO CInt + +{- | +Returns whether the /@navigation@/ was redirected. + +/Since: 2.20/ +-} +navigationActionIsRedirect :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m Bool + {- ^ __Returns:__ 'True' if the original navigation was redirected, 'False' otherwise. -} +navigationActionIsRedirect navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_is_redirect navigation' + let result' = (/= 0) result + touchManagedPtr navigation + return result' + +#if ENABLE_OVERLOADING +data NavigationActionIsRedirectMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo NavigationActionIsRedirectMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionIsRedirect + +#endif + +-- method NavigationAction::is_user_gesture +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNavigationAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_navigation_action_is_user_gesture" webkit_navigation_action_is_user_gesture :: + Ptr NavigationAction -> -- navigation : TInterface (Name {namespace = "WebKit2", name = "NavigationAction"}) + IO CInt + +{- | +Return whether the navigation was triggered by a user gesture like a mouse click. + +/Since: 2.6/ +-} +navigationActionIsUserGesture :: + (B.CallStack.HasCallStack, MonadIO m) => + NavigationAction + {- ^ /@navigation@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -} + -> m Bool + {- ^ __Returns:__ whether navigation action is a user gesture -} +navigationActionIsUserGesture navigation = liftIO $ do + navigation' <- unsafeManagedPtrGetPtr navigation + result <- webkit_navigation_action_is_user_gesture navigation' + let result' = (/= 0) result + touchManagedPtr navigation + return result' + +#if ENABLE_OVERLOADING +data NavigationActionIsUserGestureMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo NavigationActionIsUserGestureMethodInfo NavigationAction signature where + overloadedMethod _ = navigationActionIsUserGesture + +#endif + +#if ENABLE_OVERLOADING +type family ResolveNavigationActionMethod (t :: Symbol) (o :: *) :: * where + ResolveNavigationActionMethod "copy" o = NavigationActionCopyMethodInfo + ResolveNavigationActionMethod "free" o = NavigationActionFreeMethodInfo + ResolveNavigationActionMethod "isRedirect" o = NavigationActionIsRedirectMethodInfo + ResolveNavigationActionMethod "isUserGesture" o = NavigationActionIsUserGestureMethodInfo + ResolveNavigationActionMethod "getModifiers" o = NavigationActionGetModifiersMethodInfo + ResolveNavigationActionMethod "getMouseButton" o = NavigationActionGetMouseButtonMethodInfo + ResolveNavigationActionMethod "getNavigationType" o = NavigationActionGetNavigationTypeMethodInfo + ResolveNavigationActionMethod "getRequest" o = NavigationActionGetRequestMethodInfo + ResolveNavigationActionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNavigationActionMethod t NavigationAction, O.MethodInfo info NavigationAction p) => OL.IsLabel t (NavigationAction -> 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 + + diff --git a/GI/WebKit2/Structs/NavigationAction.hs-boot b/GI/WebKit2/Structs/NavigationAction.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/NavigationAction.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.NavigationAction 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 + +newtype NavigationAction = NavigationAction (ManagedPtr NavigationAction) +instance BoxedObject NavigationAction where +#if ENABLE_OVERLOADING +data NavigationActionCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionGetModifiersMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionGetMouseButtonMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionGetNavigationTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionGetRequestMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionIsRedirectMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationActionIsUserGestureMethodInfo +#endif diff --git a/GI/WebKit2/Structs/NetworkProxySettings.hs b/GI/WebKit2/Structs/NetworkProxySettings.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/NetworkProxySettings.hs @@ -0,0 +1,310 @@ + + +{- | +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.Structs.NetworkProxySettings + ( + +-- * Exported types + NetworkProxySettings(..) , + noNetworkProxySettings , + + + -- * Methods +-- ** addProxyForScheme #method:addProxyForScheme# + +#if ENABLE_OVERLOADING + NetworkProxySettingsAddProxyForSchemeMethodInfo, +#endif + networkProxySettingsAddProxyForScheme , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + NetworkProxySettingsCopyMethodInfo , +#endif + networkProxySettingsCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + NetworkProxySettingsFreeMethodInfo , +#endif + networkProxySettingsFree , + + +-- ** new #method:new# + + networkProxySettingsNew , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype NetworkProxySettings = NetworkProxySettings (ManagedPtr NetworkProxySettings) +foreign import ccall "webkit_network_proxy_settings_get_type" c_webkit_network_proxy_settings_get_type :: + IO GType + +instance BoxedObject NetworkProxySettings where + boxedType _ = c_webkit_network_proxy_settings_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `NetworkProxySettings`. +noNetworkProxySettings :: Maybe NetworkProxySettings +noNetworkProxySettings = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList NetworkProxySettings +type instance O.AttributeList NetworkProxySettings = NetworkProxySettingsAttributeList +type NetworkProxySettingsAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method NetworkProxySettings::new +-- method type : Constructor +-- Args : [Arg {argCName = "default_proxy_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the default proxy URI to use, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ignore_hosts", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an optional list of hosts/IP addresses to not use a proxy for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_network_proxy_settings_new" webkit_network_proxy_settings_new :: + CString -> -- default_proxy_uri : TBasicType TUTF8 + Ptr CString -> -- ignore_hosts : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr NetworkProxySettings) + +{- | +Create a new 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings' with the given /@defaultProxyUri@/ and /@ignoreHosts@/. + +The default proxy URI will be used for any URI that doesn\'t match /@ignoreHosts@/, and doesn\'t match any +of the schemes added with 'GI.WebKit2.Structs.NetworkProxySettings.networkProxySettingsAddProxyForScheme'. +If /@defaultProxyUri@/ starts with \"socks:\/\/\", it will be treated as referring to all three of the +socks5, socks4a, and socks4 proxy types. + +/@ignoreHosts@/ is a list of hostnames and IP addresses that the resolver should allow direct connections to. +Entries can be in one of 4 formats: +\ +\\ +A hostname, such as \"example.com\", \".example.com\", or \"*.example.com\", any of which match \"example.com\" or +any subdomain of it. +\<\/para>\<\/listitem> +\\ +An IPv4 or IPv6 address, such as \"192.168.1.1\", which matches only that address. +\<\/para>\<\/listitem> +\\ +A hostname or IP address followed by a port, such as \"example.com:80\", which matches whatever the hostname or IP +address would match, but only for URLs with the (explicitly) indicated port. In the case of an IPv6 address, the address +part must appear in brackets: \"[::1]:443\" +\<\/para>\<\/listitem> +\\ +An IP address range, given by a base address and prefix length, such as \"fe80::\/10\", which matches any address in that range. +\<\/para>\<\/listitem> +\<\/itemizedlist> + +Note that when dealing with Unicode hostnames, the matching is done against the ASCII form of the name. +Also note that hostname exclusions apply only to connections made to hosts identified by name, and IP address exclusions apply only +to connections made to hosts identified by address. That is, if example.com has an address of 192.168.1.1, and /@ignoreHosts@/ +contains only \"192.168.1.1\", then a connection to \"example.com\" will use the proxy, and a connection to 192.168.1.1\" will not. + +/Since: 2.16/ +-} +networkProxySettingsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@defaultProxyUri@/: the default proxy URI to use, or 'Nothing'. -} + -> Maybe ([T.Text]) + {- ^ /@ignoreHosts@/: an optional list of hosts\/IP addresses to not use a proxy for. -} + -> m NetworkProxySettings + {- ^ __Returns:__ A new 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings'. -} +networkProxySettingsNew defaultProxyUri ignoreHosts = liftIO $ do + maybeDefaultProxyUri <- case defaultProxyUri of + Nothing -> return nullPtr + Just jDefaultProxyUri -> do + jDefaultProxyUri' <- textToCString jDefaultProxyUri + return jDefaultProxyUri' + maybeIgnoreHosts <- case ignoreHosts of + Nothing -> return nullPtr + Just jIgnoreHosts -> do + jIgnoreHosts' <- packZeroTerminatedUTF8CArray jIgnoreHosts + return jIgnoreHosts' + result <- webkit_network_proxy_settings_new maybeDefaultProxyUri maybeIgnoreHosts + checkUnexpectedReturnNULL "networkProxySettingsNew" result + result' <- (wrapBoxed NetworkProxySettings) result + freeMem maybeDefaultProxyUri + mapZeroTerminatedCArray freeMem maybeIgnoreHosts + freeMem maybeIgnoreHosts + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method NetworkProxySettings::add_proxy_for_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "proxy_settings", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxySettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI scheme to add a proxy for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the proxy URI to use for @uri_scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_network_proxy_settings_add_proxy_for_scheme" webkit_network_proxy_settings_add_proxy_for_scheme :: + Ptr NetworkProxySettings -> -- proxy_settings : TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}) + CString -> -- scheme : TBasicType TUTF8 + CString -> -- proxy_uri : TBasicType TUTF8 + IO () + +{- | +Adds a URI-scheme-specific proxy. URIs whose scheme matches /@uriScheme@/ will be proxied via /@proxyUri@/. +As with the default proxy URI, if /@proxyUri@/ starts with \"socks:\/\/\", it will be treated as referring to +all three of the socks5, socks4a, and socks4 proxy types. + +/Since: 2.16/ +-} +networkProxySettingsAddProxyForScheme :: + (B.CallStack.HasCallStack, MonadIO m) => + NetworkProxySettings + {- ^ /@proxySettings@/: a 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings' -} + -> T.Text + {- ^ /@scheme@/: the URI scheme to add a proxy for -} + -> T.Text + {- ^ /@proxyUri@/: the proxy URI to use for /@uriScheme@/ -} + -> m () +networkProxySettingsAddProxyForScheme proxySettings scheme proxyUri = liftIO $ do + proxySettings' <- unsafeManagedPtrGetPtr proxySettings + scheme' <- textToCString scheme + proxyUri' <- textToCString proxyUri + webkit_network_proxy_settings_add_proxy_for_scheme proxySettings' scheme' proxyUri' + touchManagedPtr proxySettings + freeMem scheme' + freeMem proxyUri' + return () + +#if ENABLE_OVERLOADING +data NetworkProxySettingsAddProxyForSchemeMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.MethodInfo NetworkProxySettingsAddProxyForSchemeMethodInfo NetworkProxySettings signature where + overloadedMethod _ = networkProxySettingsAddProxyForScheme + +#endif + +-- method NetworkProxySettings::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "proxy_settings", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxySettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_network_proxy_settings_copy" webkit_network_proxy_settings_copy :: + Ptr NetworkProxySettings -> -- proxy_settings : TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}) + IO (Ptr NetworkProxySettings) + +{- | +Make a copy of the 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings'. + +/Since: 2.16/ +-} +networkProxySettingsCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + NetworkProxySettings + {- ^ /@proxySettings@/: a 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings' -} + -> m NetworkProxySettings + {- ^ __Returns:__ A copy of passed in 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings' -} +networkProxySettingsCopy proxySettings = liftIO $ do + proxySettings' <- unsafeManagedPtrGetPtr proxySettings + result <- webkit_network_proxy_settings_copy proxySettings' + checkUnexpectedReturnNULL "networkProxySettingsCopy" result + result' <- (wrapBoxed NetworkProxySettings) result + touchManagedPtr proxySettings + return result' + +#if ENABLE_OVERLOADING +data NetworkProxySettingsCopyMethodInfo +instance (signature ~ (m NetworkProxySettings), MonadIO m) => O.MethodInfo NetworkProxySettingsCopyMethodInfo NetworkProxySettings signature where + overloadedMethod _ = networkProxySettingsCopy + +#endif + +-- method NetworkProxySettings::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "proxy_settings", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitNetworkProxySettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_network_proxy_settings_free" webkit_network_proxy_settings_free :: + Ptr NetworkProxySettings -> -- proxy_settings : TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}) + IO () + +{- | +Free the 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings'. + +/Since: 2.16/ +-} +networkProxySettingsFree :: + (B.CallStack.HasCallStack, MonadIO m) => + NetworkProxySettings + {- ^ /@proxySettings@/: A 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings' -} + -> m () +networkProxySettingsFree proxySettings = liftIO $ do + proxySettings' <- unsafeManagedPtrGetPtr proxySettings + webkit_network_proxy_settings_free proxySettings' + touchManagedPtr proxySettings + return () + +#if ENABLE_OVERLOADING +data NetworkProxySettingsFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NetworkProxySettingsFreeMethodInfo NetworkProxySettings signature where + overloadedMethod _ = networkProxySettingsFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveNetworkProxySettingsMethod (t :: Symbol) (o :: *) :: * where + ResolveNetworkProxySettingsMethod "addProxyForScheme" o = NetworkProxySettingsAddProxyForSchemeMethodInfo + ResolveNetworkProxySettingsMethod "copy" o = NetworkProxySettingsCopyMethodInfo + ResolveNetworkProxySettingsMethod "free" o = NetworkProxySettingsFreeMethodInfo + ResolveNetworkProxySettingsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNetworkProxySettingsMethod t NetworkProxySettings, O.MethodInfo info NetworkProxySettings p) => OL.IsLabel t (NetworkProxySettings -> 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 + + diff --git a/GI/WebKit2/Structs/NetworkProxySettings.hs-boot b/GI/WebKit2/Structs/NetworkProxySettings.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/NetworkProxySettings.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.NetworkProxySettings 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 + +newtype NetworkProxySettings = NetworkProxySettings (ManagedPtr NetworkProxySettings) +instance BoxedObject NetworkProxySettings where +#if ENABLE_OVERLOADING +data NetworkProxySettingsAddProxyForSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data NetworkProxySettingsCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data NetworkProxySettingsFreeMethodInfo +#endif diff --git a/GI/WebKit2/Structs/OptionMenuItem.hs b/GI/WebKit2/Structs/OptionMenuItem.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/OptionMenuItem.hs @@ -0,0 +1,450 @@ + + +{- | +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.Structs.OptionMenuItem + ( + +-- * Exported types + OptionMenuItem(..) , + noOptionMenuItem , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + OptionMenuItemCopyMethodInfo , +#endif + optionMenuItemCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + OptionMenuItemFreeMethodInfo , +#endif + optionMenuItemFree , + + +-- ** getLabel #method:getLabel# + +#if ENABLE_OVERLOADING + OptionMenuItemGetLabelMethodInfo , +#endif + optionMenuItemGetLabel , + + +-- ** getTooltip #method:getTooltip# + +#if ENABLE_OVERLOADING + OptionMenuItemGetTooltipMethodInfo , +#endif + optionMenuItemGetTooltip , + + +-- ** isEnabled #method:isEnabled# + +#if ENABLE_OVERLOADING + OptionMenuItemIsEnabledMethodInfo , +#endif + optionMenuItemIsEnabled , + + +-- ** isGroupChild #method:isGroupChild# + +#if ENABLE_OVERLOADING + OptionMenuItemIsGroupChildMethodInfo , +#endif + optionMenuItemIsGroupChild , + + +-- ** isGroupLabel #method:isGroupLabel# + +#if ENABLE_OVERLOADING + OptionMenuItemIsGroupLabelMethodInfo , +#endif + optionMenuItemIsGroupLabel , + + +-- ** isSelected #method:isSelected# + +#if ENABLE_OVERLOADING + OptionMenuItemIsSelectedMethodInfo , +#endif + optionMenuItemIsSelected , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype OptionMenuItem = OptionMenuItem (ManagedPtr OptionMenuItem) +foreign import ccall "webkit_option_menu_item_get_type" c_webkit_option_menu_item_get_type :: + IO GType + +instance BoxedObject OptionMenuItem where + boxedType _ = c_webkit_option_menu_item_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `OptionMenuItem`. +noOptionMenuItem :: Maybe OptionMenuItem +noOptionMenuItem = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList OptionMenuItem +type instance O.AttributeList OptionMenuItem = OptionMenuItemAttributeList +type OptionMenuItemAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method OptionMenuItem::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_copy" webkit_option_menu_item_copy :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO (Ptr OptionMenuItem) + +{- | +Make a copy of the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'. + +/Since: 2.18/ +-} +optionMenuItemCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m OptionMenuItem + {- ^ __Returns:__ A copy of passed in 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} +optionMenuItemCopy item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_copy item' + checkUnexpectedReturnNULL "optionMenuItemCopy" result + result' <- (wrapBoxed OptionMenuItem) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemCopyMethodInfo +instance (signature ~ (m OptionMenuItem), MonadIO m) => O.MethodInfo OptionMenuItemCopyMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemCopy + +#endif + +-- method OptionMenuItem::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_free" webkit_option_menu_item_free :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO () + +{- | +Free the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'. + +/Since: 2.18/ +-} +optionMenuItemFree :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: A 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m () +optionMenuItemFree item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + webkit_option_menu_item_free item' + touchManagedPtr item + return () + +#if ENABLE_OVERLOADING +data OptionMenuItemFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo OptionMenuItemFreeMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemFree + +#endif + +-- method OptionMenuItem::get_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", 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_option_menu_item_get_label" webkit_option_menu_item_get_label :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CString + +{- | +Get the label of a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'. + +/Since: 2.18/ +-} +optionMenuItemGetLabel :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m T.Text + {- ^ __Returns:__ The label of /@item@/. -} +optionMenuItemGetLabel item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_get_label item' + checkUnexpectedReturnNULL "optionMenuItemGetLabel" result + result' <- cstringToText result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemGetLabelMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo OptionMenuItemGetLabelMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemGetLabel + +#endif + +-- method OptionMenuItem::get_tooltip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", 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_option_menu_item_get_tooltip" webkit_option_menu_item_get_tooltip :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CString + +{- | +Get the tooltip of a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'. + +/Since: 2.18/ +-} +optionMenuItemGetTooltip :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ The tooltip of /@item@/, or 'Nothing'. -} +optionMenuItemGetTooltip item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_get_tooltip item' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr item + return maybeResult + +#if ENABLE_OVERLOADING +data OptionMenuItemGetTooltipMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo OptionMenuItemGetTooltipMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemGetTooltip + +#endif + +-- method OptionMenuItem::is_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_is_enabled" webkit_option_menu_item_is_enabled :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CInt + +{- | +Whether a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' is enabled. + +/Since: 2.18/ +-} +optionMenuItemIsEnabled :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m Bool + {- ^ __Returns:__ 'True' if the /@item@/ is enabled or 'False' otherwise. -} +optionMenuItemIsEnabled item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_is_enabled item' + let result' = (/= 0) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemIsEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo OptionMenuItemIsEnabledMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemIsEnabled + +#endif + +-- method OptionMenuItem::is_group_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_is_group_child" webkit_option_menu_item_is_group_child :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CInt + +{- | +Whether a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' is a group child. + +/Since: 2.18/ +-} +optionMenuItemIsGroupChild :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m Bool + {- ^ __Returns:__ 'True' if the /@item@/ is a group child or 'False' otherwise. -} +optionMenuItemIsGroupChild item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_is_group_child item' + let result' = (/= 0) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemIsGroupChildMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo OptionMenuItemIsGroupChildMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemIsGroupChild + +#endif + +-- method OptionMenuItem::is_group_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_is_group_label" webkit_option_menu_item_is_group_label :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CInt + +{- | +Whether a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' is a group label. + +/Since: 2.18/ +-} +optionMenuItemIsGroupLabel :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m Bool + {- ^ __Returns:__ 'True' if the /@item@/ is a group label or 'False' otherwise. -} +optionMenuItemIsGroupLabel item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_is_group_label item' + let result' = (/= 0) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemIsGroupLabelMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo OptionMenuItemIsGroupLabelMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemIsGroupLabel + +#endif + +-- method OptionMenuItem::is_selected +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenuItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_option_menu_item_is_selected" webkit_option_menu_item_is_selected :: + Ptr OptionMenuItem -> -- item : TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}) + IO CInt + +{- | +Whether a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' is the currently selected one. + +/Since: 2.18/ +-} +optionMenuItemIsSelected :: + (B.CallStack.HasCallStack, MonadIO m) => + OptionMenuItem + {- ^ /@item@/: a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' -} + -> m Bool + {- ^ __Returns:__ 'True' if the /@item@/ is selected or 'False' otherwise. -} +optionMenuItemIsSelected item = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + result <- webkit_option_menu_item_is_selected item' + let result' = (/= 0) result + touchManagedPtr item + return result' + +#if ENABLE_OVERLOADING +data OptionMenuItemIsSelectedMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo OptionMenuItemIsSelectedMethodInfo OptionMenuItem signature where + overloadedMethod _ = optionMenuItemIsSelected + +#endif + +#if ENABLE_OVERLOADING +type family ResolveOptionMenuItemMethod (t :: Symbol) (o :: *) :: * where + ResolveOptionMenuItemMethod "copy" o = OptionMenuItemCopyMethodInfo + ResolveOptionMenuItemMethod "free" o = OptionMenuItemFreeMethodInfo + ResolveOptionMenuItemMethod "isEnabled" o = OptionMenuItemIsEnabledMethodInfo + ResolveOptionMenuItemMethod "isGroupChild" o = OptionMenuItemIsGroupChildMethodInfo + ResolveOptionMenuItemMethod "isGroupLabel" o = OptionMenuItemIsGroupLabelMethodInfo + ResolveOptionMenuItemMethod "isSelected" o = OptionMenuItemIsSelectedMethodInfo + ResolveOptionMenuItemMethod "getLabel" o = OptionMenuItemGetLabelMethodInfo + ResolveOptionMenuItemMethod "getTooltip" o = OptionMenuItemGetTooltipMethodInfo + ResolveOptionMenuItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveOptionMenuItemMethod t OptionMenuItem, O.MethodInfo info OptionMenuItem p) => OL.IsLabel t (OptionMenuItem -> 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 + + diff --git a/GI/WebKit2/Structs/OptionMenuItem.hs-boot b/GI/WebKit2/Structs/OptionMenuItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/OptionMenuItem.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.OptionMenuItem 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 + +newtype OptionMenuItem = OptionMenuItem (ManagedPtr OptionMenuItem) +instance BoxedObject OptionMenuItem where +#if ENABLE_OVERLOADING +data OptionMenuItemCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemGetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemGetTooltipMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemIsEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemIsGroupChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemIsGroupLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data OptionMenuItemIsSelectedMethodInfo +#endif diff --git a/GI/WebKit2/Structs/ScriptDialog.hs b/GI/WebKit2/Structs/ScriptDialog.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/ScriptDialog.hs @@ -0,0 +1,462 @@ + + +{- | +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.Structs.ScriptDialog + ( + +-- * Exported types + ScriptDialog(..) , + noScriptDialog , + + + -- * Methods +-- ** close #method:close# + +#if ENABLE_OVERLOADING + ScriptDialogCloseMethodInfo , +#endif + scriptDialogClose , + + +-- ** confirmSetConfirmed #method:confirmSetConfirmed# + +#if ENABLE_OVERLOADING + ScriptDialogConfirmSetConfirmedMethodInfo, +#endif + scriptDialogConfirmSetConfirmed , + + +-- ** getDialogType #method:getDialogType# + +#if ENABLE_OVERLOADING + ScriptDialogGetDialogTypeMethodInfo , +#endif + scriptDialogGetDialogType , + + +-- ** getMessage #method:getMessage# + +#if ENABLE_OVERLOADING + ScriptDialogGetMessageMethodInfo , +#endif + scriptDialogGetMessage , + + +-- ** promptGetDefaultText #method:promptGetDefaultText# + +#if ENABLE_OVERLOADING + ScriptDialogPromptGetDefaultTextMethodInfo, +#endif + scriptDialogPromptGetDefaultText , + + +-- ** promptSetText #method:promptSetText# + +#if ENABLE_OVERLOADING + ScriptDialogPromptSetTextMethodInfo , +#endif + scriptDialogPromptSetText , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + ScriptDialogRefMethodInfo , +#endif + scriptDialogRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + ScriptDialogUnrefMethodInfo , +#endif + scriptDialogUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype ScriptDialog = ScriptDialog (ManagedPtr ScriptDialog) +foreign import ccall "webkit_script_dialog_get_type" c_webkit_script_dialog_get_type :: + IO GType + +instance BoxedObject ScriptDialog where + boxedType _ = c_webkit_script_dialog_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `ScriptDialog`. +noScriptDialog :: Maybe ScriptDialog +noScriptDialog = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ScriptDialog +type instance O.AttributeList ScriptDialog = ScriptDialogAttributeList +type ScriptDialogAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method ScriptDialog::close +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_close" webkit_script_dialog_close :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO () + +{- | +Close /@dialog@/. When handling a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' asynchronously ('GI.WebKit2.Structs.ScriptDialog.scriptDialogRef' +was called in 'GI.WebKit2.Objects.WebView.WebView'::@/script-dialog/@ callback), this function needs to be called to notify +that we are done with the script dialog. The dialog will be closed on destruction if this function +hasn\'t been called before. + +/Since: 2.24/ +-} +scriptDialogClose :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m () +scriptDialogClose dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + webkit_script_dialog_close dialog' + touchManagedPtr dialog + return () + +#if ENABLE_OVERLOADING +data ScriptDialogCloseMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ScriptDialogCloseMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogClose + +#endif + +-- method ScriptDialog::confirm_set_confirmed +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "confirmed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether user confirmed the dialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_confirm_set_confirmed" webkit_script_dialog_confirm_set_confirmed :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + CInt -> -- confirmed : TBasicType TBoolean + IO () + +{- | +This method is used for 'GI.WebKit2.Enums.ScriptDialogTypeConfirm' and 'GI.WebKit2.Enums.ScriptDialogTypeBeforeUnloadConfirm' dialogs when +'GI.WebKit2.Objects.WebView.WebView'::@/script-dialog/@ signal is emitted to set whether the user +confirmed the dialog or not. The default implementation of 'GI.WebKit2.Objects.WebView.WebView'::@/script-dialog/@ +signal sets 'True' when the OK or Stay buttons are clicked and 'False' otherwise. +It\'s an error to use this method with a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' that is not of type +'GI.WebKit2.Enums.ScriptDialogTypeConfirm' or 'GI.WebKit2.Enums.ScriptDialogTypeBeforeUnloadConfirm' +-} +scriptDialogConfirmSetConfirmed :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> Bool + {- ^ /@confirmed@/: whether user confirmed the dialog -} + -> m () +scriptDialogConfirmSetConfirmed dialog confirmed = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + let confirmed' = (fromIntegral . fromEnum) confirmed + webkit_script_dialog_confirm_set_confirmed dialog' confirmed' + touchManagedPtr dialog + return () + +#if ENABLE_OVERLOADING +data ScriptDialogConfirmSetConfirmedMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo ScriptDialogConfirmSetConfirmedMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogConfirmSetConfirmed + +#endif + +-- method ScriptDialog::get_dialog_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ScriptDialogType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_get_dialog_type" webkit_script_dialog_get_dialog_type :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO CUInt + +{- | +Get the dialog type of a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog'. +-} +scriptDialogGetDialogType :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m WebKit2.Enums.ScriptDialogType + {- ^ __Returns:__ the 'GI.WebKit2.Enums.ScriptDialogType' of /@dialog@/ -} +scriptDialogGetDialogType dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + result <- webkit_script_dialog_get_dialog_type dialog' + let result' = (toEnum . fromIntegral) result + touchManagedPtr dialog + return result' + +#if ENABLE_OVERLOADING +data ScriptDialogGetDialogTypeMethodInfo +instance (signature ~ (m WebKit2.Enums.ScriptDialogType), MonadIO m) => O.MethodInfo ScriptDialogGetDialogTypeMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogGetDialogType + +#endif + +-- method ScriptDialog::get_message +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", 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_script_dialog_get_message" webkit_script_dialog_get_message :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO CString + +{- | +Get the message of a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog'. +-} +scriptDialogGetMessage :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m T.Text + {- ^ __Returns:__ the message of /@dialog@/. -} +scriptDialogGetMessage dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + result <- webkit_script_dialog_get_message dialog' + checkUnexpectedReturnNULL "scriptDialogGetMessage" result + result' <- cstringToText result + touchManagedPtr dialog + return result' + +#if ENABLE_OVERLOADING +data ScriptDialogGetMessageMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ScriptDialogGetMessageMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogGetMessage + +#endif + +-- method ScriptDialog::prompt_get_default_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", 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_script_dialog_prompt_get_default_text" webkit_script_dialog_prompt_get_default_text :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO CString + +{- | +Get the default text of a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' of type 'GI.WebKit2.Enums.ScriptDialogTypePrompt'. +It\'s an error to use this method with a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' that is not of type +'GI.WebKit2.Enums.ScriptDialogTypePrompt'. +-} +scriptDialogPromptGetDefaultText :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m T.Text + {- ^ __Returns:__ the default text of /@dialog@/ -} +scriptDialogPromptGetDefaultText dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + result <- webkit_script_dialog_prompt_get_default_text dialog' + checkUnexpectedReturnNULL "scriptDialogPromptGetDefaultText" result + result' <- cstringToText result + touchManagedPtr dialog + return result' + +#if ENABLE_OVERLOADING +data ScriptDialogPromptGetDefaultTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo ScriptDialogPromptGetDefaultTextMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogPromptGetDefaultText + +#endif + +-- method ScriptDialog::prompt_set_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_prompt_set_text" webkit_script_dialog_prompt_set_text :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + CString -> -- text : TBasicType TUTF8 + IO () + +{- | +This method is used for 'GI.WebKit2.Enums.ScriptDialogTypePrompt' dialogs when +'GI.WebKit2.Objects.WebView.WebView'::@/script-dialog/@ signal is emitted to set the text +entered by the user. The default implementation of 'GI.WebKit2.Objects.WebView.WebView'::@/script-dialog/@ +signal sets the text of the entry form when OK button is clicked, otherwise 'Nothing' is set. +It\'s an error to use this method with a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' that is not of type +'GI.WebKit2.Enums.ScriptDialogTypePrompt'. +-} +scriptDialogPromptSetText :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> T.Text + {- ^ /@text@/: the text to set -} + -> m () +scriptDialogPromptSetText dialog text = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + text' <- textToCString text + webkit_script_dialog_prompt_set_text dialog' text' + touchManagedPtr dialog + freeMem text' + return () + +#if ENABLE_OVERLOADING +data ScriptDialogPromptSetTextMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo ScriptDialogPromptSetTextMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogPromptSetText + +#endif + +-- method ScriptDialog::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_ref" webkit_script_dialog_ref :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO (Ptr ScriptDialog) + +{- | +Atomically increments the reference count of /@dialog@/ by one. This +function is MT-safe and may be called from any thread. + +/Since: 2.24/ +-} +scriptDialogRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m ScriptDialog + {- ^ __Returns:__ The passed in 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} +scriptDialogRef dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + result <- webkit_script_dialog_ref dialog' + checkUnexpectedReturnNULL "scriptDialogRef" result + result' <- (wrapBoxed ScriptDialog) result + touchManagedPtr dialog + return result' + +#if ENABLE_OVERLOADING +data ScriptDialogRefMethodInfo +instance (signature ~ (m ScriptDialog), MonadIO m) => O.MethodInfo ScriptDialogRefMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogRef + +#endif + +-- method ScriptDialog::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dialog", argType = TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitScriptDialog", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_script_dialog_unref" webkit_script_dialog_unref :: + Ptr ScriptDialog -> -- dialog : TInterface (Name {namespace = "WebKit2", name = "ScriptDialog"}) + IO () + +{- | +Atomically decrements the reference count of /@dialog@/ by one. If the +reference count drops to 0, all memory allocated by the @/WebKitScriptdialog/@ is +released. This function is MT-safe and may be called from any +thread. + +/Since: 2.24/ +-} +scriptDialogUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ScriptDialog + {- ^ /@dialog@/: a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' -} + -> m () +scriptDialogUnref dialog = liftIO $ do + dialog' <- unsafeManagedPtrGetPtr dialog + webkit_script_dialog_unref dialog' + touchManagedPtr dialog + return () + +#if ENABLE_OVERLOADING +data ScriptDialogUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ScriptDialogUnrefMethodInfo ScriptDialog signature where + overloadedMethod _ = scriptDialogUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveScriptDialogMethod (t :: Symbol) (o :: *) :: * where + ResolveScriptDialogMethod "close" o = ScriptDialogCloseMethodInfo + ResolveScriptDialogMethod "confirmSetConfirmed" o = ScriptDialogConfirmSetConfirmedMethodInfo + ResolveScriptDialogMethod "promptGetDefaultText" o = ScriptDialogPromptGetDefaultTextMethodInfo + ResolveScriptDialogMethod "promptSetText" o = ScriptDialogPromptSetTextMethodInfo + ResolveScriptDialogMethod "ref" o = ScriptDialogRefMethodInfo + ResolveScriptDialogMethod "unref" o = ScriptDialogUnrefMethodInfo + ResolveScriptDialogMethod "getDialogType" o = ScriptDialogGetDialogTypeMethodInfo + ResolveScriptDialogMethod "getMessage" o = ScriptDialogGetMessageMethodInfo + ResolveScriptDialogMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveScriptDialogMethod t ScriptDialog, O.MethodInfo info ScriptDialog p) => OL.IsLabel t (ScriptDialog -> 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 + + diff --git a/GI/WebKit2/Structs/ScriptDialog.hs-boot b/GI/WebKit2/Structs/ScriptDialog.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/ScriptDialog.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.ScriptDialog 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 + +newtype ScriptDialog = ScriptDialog (ManagedPtr ScriptDialog) +instance BoxedObject ScriptDialog where +#if ENABLE_OVERLOADING +data ScriptDialogCloseMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogConfirmSetConfirmedMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogGetDialogTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogGetMessageMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogPromptGetDefaultTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogPromptSetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data ScriptDialogUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/SecurityOrigin.hs b/GI/WebKit2/Structs/SecurityOrigin.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/SecurityOrigin.hs @@ -0,0 +1,510 @@ + + +{- | +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.Structs.SecurityOrigin + ( + +-- * Exported types + SecurityOrigin(..) , + noSecurityOrigin , + + + -- * Methods +-- ** getHost #method:getHost# + +#if ENABLE_OVERLOADING + SecurityOriginGetHostMethodInfo , +#endif + securityOriginGetHost , + + +-- ** getPort #method:getPort# + +#if ENABLE_OVERLOADING + SecurityOriginGetPortMethodInfo , +#endif + securityOriginGetPort , + + +-- ** getProtocol #method:getProtocol# + +#if ENABLE_OVERLOADING + SecurityOriginGetProtocolMethodInfo , +#endif + securityOriginGetProtocol , + + +-- ** isOpaque #method:isOpaque# + +#if ENABLE_OVERLOADING + SecurityOriginIsOpaqueMethodInfo , +#endif + securityOriginIsOpaque , + + +-- ** new #method:new# + + securityOriginNew , + + +-- ** newForUri #method:newForUri# + + securityOriginNewForUri , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + SecurityOriginRefMethodInfo , +#endif + securityOriginRef , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + SecurityOriginToStringMethodInfo , +#endif + securityOriginToString , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + SecurityOriginUnrefMethodInfo , +#endif + securityOriginUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype SecurityOrigin = SecurityOrigin (ManagedPtr SecurityOrigin) +foreign import ccall "webkit_security_origin_get_type" c_webkit_security_origin_get_type :: + IO GType + +instance BoxedObject SecurityOrigin where + boxedType _ = c_webkit_security_origin_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `SecurityOrigin`. +noSecurityOrigin :: Maybe SecurityOrigin +noSecurityOrigin = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SecurityOrigin +type instance O.AttributeList SecurityOrigin = SecurityOriginAttributeList +type SecurityOriginAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method SecurityOrigin::new +-- method type : Constructor +-- Args : [Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The protocol for the new origin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The host for the new origin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The port number for the new origin, or 0 to indicate the\n default port for @protocol", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_new" webkit_security_origin_new :: + CString -> -- protocol : TBasicType TUTF8 + CString -> -- host : TBasicType TUTF8 + Word16 -> -- port : TBasicType TUInt16 + IO (Ptr SecurityOrigin) + +{- | +Create a new security origin from the provided protocol, host and +port. + +/Since: 2.16/ +-} +securityOriginNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@protocol@/: The protocol for the new origin -} + -> T.Text + {- ^ /@host@/: The host for the new origin -} + -> Word16 + {- ^ /@port@/: The port number for the new origin, or 0 to indicate the + default port for /@protocol@/ -} + -> m SecurityOrigin + {- ^ __Returns:__ A 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -} +securityOriginNew protocol host port = liftIO $ do + protocol' <- textToCString protocol + host' <- textToCString host + result <- webkit_security_origin_new protocol' host' port + checkUnexpectedReturnNULL "securityOriginNew" result + result' <- (wrapBoxed SecurityOrigin) result + freeMem protocol' + freeMem host' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method SecurityOrigin::new_for_uri +-- method type : Constructor +-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The URI for the new origin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_new_for_uri" webkit_security_origin_new_for_uri :: + CString -> -- uri : TBasicType TUTF8 + IO (Ptr SecurityOrigin) + +{- | +Create a new security origin from the provided URI. Components of +/@uri@/ other than protocol, host, and port do not affect the created +'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. + +/Since: 2.16/ +-} +securityOriginNewForUri :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@uri@/: The URI for the new origin -} + -> m SecurityOrigin + {- ^ __Returns:__ A 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -} +securityOriginNewForUri uri = liftIO $ do + uri' <- textToCString uri + result <- webkit_security_origin_new_for_uri uri' + checkUnexpectedReturnNULL "securityOriginNewForUri" result + result' <- (wrapBoxed SecurityOrigin) result + freeMem uri' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method SecurityOrigin::get_host +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", 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_security_origin_get_host" webkit_security_origin_get_host :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO CString + +{- | +Gets the hostname of /@origin@/, or 'Nothing' if /@origin@/ is opaque or if its +protocol does not require a host component. + +/Since: 2.16/ +-} +securityOriginGetHost :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ The host of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} +securityOriginGetHost origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_get_host origin' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr origin + return maybeResult + +#if ENABLE_OVERLOADING +data SecurityOriginGetHostMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginGetHostMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginGetHost + +#endif + +-- method SecurityOrigin::get_port +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt16) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_get_port" webkit_security_origin_get_port :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO Word16 + +{- | +Gets the port of /@origin@/. This function will always return 0 if the +port is the default port for the given protocol. For example, +http:\/\/example.com has the same security origin as +http:\/\/example.com:80, and this function will return 0 for a +'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' constructed from either URI. It will also +return 0 if /@origin@/ is opaque. + +/Since: 2.16/ +-} +securityOriginGetPort :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m Word16 + {- ^ __Returns:__ The port of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -} +securityOriginGetPort origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_get_port origin' + touchManagedPtr origin + return result + +#if ENABLE_OVERLOADING +data SecurityOriginGetPortMethodInfo +instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo SecurityOriginGetPortMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginGetPort + +#endif + +-- method SecurityOrigin::get_protocol +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", 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_security_origin_get_protocol" webkit_security_origin_get_protocol :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO CString + +{- | +Gets the protocol of /@origin@/, or 'Nothing' if /@origin@/ is opaque. + +/Since: 2.16/ +-} +securityOriginGetProtocol :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ The protocol of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} +securityOriginGetProtocol origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_get_protocol origin' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr origin + return maybeResult + +#if ENABLE_OVERLOADING +data SecurityOriginGetProtocolMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginGetProtocolMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginGetProtocol + +#endif + +-- method SecurityOrigin::is_opaque +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_is_opaque" webkit_security_origin_is_opaque :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO CInt + +{- | +Gets whether /@origin@/ is an opaque security origin, which does not +possess an associated protocol, host, or port. + +/Since: 2.16/ +-} +securityOriginIsOpaque :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@origin@/ is opaque. -} +securityOriginIsOpaque origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_is_opaque origin' + let result' = (/= 0) result + touchManagedPtr origin + return result' + +#if ENABLE_OVERLOADING +data SecurityOriginIsOpaqueMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo SecurityOriginIsOpaqueMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginIsOpaque + +#endif + +-- method SecurityOrigin::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_ref" webkit_security_origin_ref :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO (Ptr SecurityOrigin) + +{- | +Atomically increments the reference count of /@origin@/ by one. +This function is MT-safe and may be called from any thread. + +/Since: 2.16/ +-} +securityOriginRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m SecurityOrigin + {- ^ __Returns:__ The passed 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} +securityOriginRef origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_ref origin' + checkUnexpectedReturnNULL "securityOriginRef" result + result' <- (wrapBoxed SecurityOrigin) result + touchManagedPtr origin + return result' + +#if ENABLE_OVERLOADING +data SecurityOriginRefMethodInfo +instance (signature ~ (m SecurityOrigin), MonadIO m) => O.MethodInfo SecurityOriginRefMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginRef + +#endif + +-- method SecurityOrigin::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSecurityOrigin", 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_security_origin_to_string" webkit_security_origin_to_string :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO CString + +{- | +Gets a string representation of /@origin@/. The string representation +is a valid URI with only protocol, host, and port components. It may +be 'Nothing', but usually only if /@origin@/ is opaque. + +/Since: 2.16/ +-} +securityOriginToString :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a URI representing /@origin@/. -} +securityOriginToString origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + result <- webkit_security_origin_to_string origin' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr origin + return maybeResult + +#if ENABLE_OVERLOADING +data SecurityOriginToStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginToStringMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginToString + +#endif + +-- method SecurityOrigin::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "origin", argType = TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitSecurityOrigin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_security_origin_unref" webkit_security_origin_unref :: + Ptr SecurityOrigin -> -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}) + IO () + +{- | +Atomically decrements the reference count of /@origin@/ by one. +If the reference count drops to 0, all memory allocated by +'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' is released. This function is MT-safe and may be +called from any thread. + +/Since: 2.16/ +-} +securityOriginUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SecurityOrigin + {- ^ /@origin@/: A 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -} + -> m () +securityOriginUnref origin = liftIO $ do + origin' <- unsafeManagedPtrGetPtr origin + webkit_security_origin_unref origin' + touchManagedPtr origin + return () + +#if ENABLE_OVERLOADING +data SecurityOriginUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SecurityOriginUnrefMethodInfo SecurityOrigin signature where + overloadedMethod _ = securityOriginUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveSecurityOriginMethod (t :: Symbol) (o :: *) :: * where + ResolveSecurityOriginMethod "isOpaque" o = SecurityOriginIsOpaqueMethodInfo + ResolveSecurityOriginMethod "ref" o = SecurityOriginRefMethodInfo + ResolveSecurityOriginMethod "toString" o = SecurityOriginToStringMethodInfo + ResolveSecurityOriginMethod "unref" o = SecurityOriginUnrefMethodInfo + ResolveSecurityOriginMethod "getHost" o = SecurityOriginGetHostMethodInfo + ResolveSecurityOriginMethod "getPort" o = SecurityOriginGetPortMethodInfo + ResolveSecurityOriginMethod "getProtocol" o = SecurityOriginGetProtocolMethodInfo + ResolveSecurityOriginMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSecurityOriginMethod t SecurityOrigin, O.MethodInfo info SecurityOrigin p) => OL.IsLabel t (SecurityOrigin -> 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 + + diff --git a/GI/WebKit2/Structs/SecurityOrigin.hs-boot b/GI/WebKit2/Structs/SecurityOrigin.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/SecurityOrigin.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.SecurityOrigin 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 + +newtype SecurityOrigin = SecurityOrigin (ManagedPtr SecurityOrigin) +instance BoxedObject SecurityOrigin where +#if ENABLE_OVERLOADING +data SecurityOriginGetHostMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginGetPortMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginGetProtocolMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginIsOpaqueMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginToStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data SecurityOriginUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/UserContentFilter.hs b/GI/WebKit2/Structs/UserContentFilter.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserContentFilter.hs @@ -0,0 +1,222 @@ + + +{- | +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.Structs.UserContentFilter + ( + +-- * Exported types + UserContentFilter(..) , + noUserContentFilter , + + + -- * Methods +-- ** getIdentifier #method:getIdentifier# + +#if ENABLE_OVERLOADING + UserContentFilterGetIdentifierMethodInfo, +#endif + userContentFilterGetIdentifier , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + UserContentFilterRefMethodInfo , +#endif + userContentFilterRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + UserContentFilterUnrefMethodInfo , +#endif + userContentFilterUnref , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype UserContentFilter = UserContentFilter (ManagedPtr UserContentFilter) +foreign import ccall "webkit_user_content_filter_get_type" c_webkit_user_content_filter_get_type :: + IO GType + +instance BoxedObject UserContentFilter where + boxedType _ = c_webkit_user_content_filter_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `UserContentFilter`. +noUserContentFilter :: Maybe UserContentFilter +noUserContentFilter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserContentFilter +type instance O.AttributeList UserContentFilter = UserContentFilterAttributeList +type UserContentFilterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method UserContentFilter::get_identifier +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_content_filter", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentFilter", 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_user_content_filter_get_identifier" webkit_user_content_filter_get_identifier :: + Ptr UserContentFilter -> -- user_content_filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}) + IO CString + +{- | +Obtain the identifier previously used to save the /@userContentFilter@/ in the +'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore'. + +/Since: 2.24/ +-} +userContentFilterGetIdentifier :: + (B.CallStack.HasCallStack, MonadIO m) => + UserContentFilter + {- ^ /@userContentFilter@/: A 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' -} + -> m T.Text + {- ^ __Returns:__ the identifier for the filter -} +userContentFilterGetIdentifier userContentFilter = liftIO $ do + userContentFilter' <- unsafeManagedPtrGetPtr userContentFilter + result <- webkit_user_content_filter_get_identifier userContentFilter' + checkUnexpectedReturnNULL "userContentFilterGetIdentifier" result + result' <- cstringToText result + touchManagedPtr userContentFilter + return result' + +#if ENABLE_OVERLOADING +data UserContentFilterGetIdentifierMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo UserContentFilterGetIdentifierMethodInfo UserContentFilter signature where + overloadedMethod _ = userContentFilterGetIdentifier + +#endif + +-- method UserContentFilter::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_content_filter", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_ref" webkit_user_content_filter_ref :: + Ptr UserContentFilter -> -- user_content_filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}) + IO (Ptr UserContentFilter) + +{- | +Atomically increments the reference count of /@userContentFilter@/ by one. +This function is MT-safe and may be called from any thread. + +/Since: 2.24/ +-} +userContentFilterRef :: + (B.CallStack.HasCallStack, MonadIO m) => + UserContentFilter + {- ^ /@userContentFilter@/: A 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' -} + -> m UserContentFilter +userContentFilterRef userContentFilter = liftIO $ do + userContentFilter' <- unsafeManagedPtrGetPtr userContentFilter + result <- webkit_user_content_filter_ref userContentFilter' + checkUnexpectedReturnNULL "userContentFilterRef" result + result' <- (wrapBoxed UserContentFilter) result + touchManagedPtr userContentFilter + return result' + +#if ENABLE_OVERLOADING +data UserContentFilterRefMethodInfo +instance (signature ~ (m UserContentFilter), MonadIO m) => O.MethodInfo UserContentFilterRefMethodInfo UserContentFilter signature where + overloadedMethod _ = userContentFilterRef + +#endif + +-- method UserContentFilter::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_content_filter", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_content_filter_unref" webkit_user_content_filter_unref :: + Ptr UserContentFilter -> -- user_content_filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"}) + IO () + +{- | +Atomically decrements the reference count of /@userContentFilter@/ by one. +If the reference count drops to 0, all the memory allocated by the +'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' is released. This function is MT-safe and may +be called from any thread. + +/Since: 2.24/ +-} +userContentFilterUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + UserContentFilter + {- ^ /@userContentFilter@/: A 'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' -} + -> m () +userContentFilterUnref userContentFilter = liftIO $ do + userContentFilter' <- unsafeManagedPtrGetPtr userContentFilter + webkit_user_content_filter_unref userContentFilter' + touchManagedPtr userContentFilter + return () + +#if ENABLE_OVERLOADING +data UserContentFilterUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo UserContentFilterUnrefMethodInfo UserContentFilter signature where + overloadedMethod _ = userContentFilterUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveUserContentFilterMethod (t :: Symbol) (o :: *) :: * where + ResolveUserContentFilterMethod "ref" o = UserContentFilterRefMethodInfo + ResolveUserContentFilterMethod "unref" o = UserContentFilterUnrefMethodInfo + ResolveUserContentFilterMethod "getIdentifier" o = UserContentFilterGetIdentifierMethodInfo + ResolveUserContentFilterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserContentFilterMethod t UserContentFilter, O.MethodInfo info UserContentFilter p) => OL.IsLabel t (UserContentFilter -> 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 + + diff --git a/GI/WebKit2/Structs/UserContentFilter.hs-boot b/GI/WebKit2/Structs/UserContentFilter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserContentFilter.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.UserContentFilter 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 + +newtype UserContentFilter = UserContentFilter (ManagedPtr UserContentFilter) +instance BoxedObject UserContentFilter where +#if ENABLE_OVERLOADING +data UserContentFilterGetIdentifierMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserContentFilterUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/UserScript.hs b/GI/WebKit2/Structs/UserScript.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserScript.hs @@ -0,0 +1,322 @@ + + +{- | +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.Structs.UserScript + ( + +-- * Exported types + UserScript(..) , + noUserScript , + + + -- * Methods +-- ** new #method:new# + + userScriptNew , + + +-- ** newForWorld #method:newForWorld# + + userScriptNewForWorld , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + UserScriptRefMethodInfo , +#endif + userScriptRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + UserScriptUnrefMethodInfo , +#endif + userScriptUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype UserScript = UserScript (ManagedPtr UserScript) +foreign import ccall "webkit_user_script_get_type" c_webkit_user_script_get_type :: + IO GType + +instance BoxedObject UserScript where + boxedType _ = c_webkit_user_script_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `UserScript`. +noUserScript :: Maybe UserScript +noUserScript = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserScript +type instance O.AttributeList UserScript = UserScriptAttributeList +type UserScriptAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method UserScript::new +-- method type : Constructor +-- Args : [Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source code of the user script.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injected_frames", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentInjectedFrames value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injection_time", argType = TInterface (Name {namespace = "WebKit2", name = "UserScriptInjectionTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserScriptInjectionTime value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whitelist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A whitelist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blacklist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A blacklist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserScript"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_script_new" webkit_user_script_new :: + CString -> -- source : TBasicType TUTF8 + CUInt -> -- injected_frames : TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}) + CUInt -> -- injection_time : TInterface (Name {namespace = "WebKit2", name = "UserScriptInjectionTime"}) + Ptr CString -> -- whitelist : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr CString -> -- blacklist : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr UserScript) + +{- | +Creates a new user script. Scripts can be applied to some URIs +only by passing non-null values for /@whitelist@/ or /@blacklist@/. Passing a +'Nothing' whitelist implies that all URIs are on the whitelist. The script +is applied if an URI matches the whitelist and not the blacklist. +URI patterns must be of the form @[protocol]:\/\/[host]\/[path]@, where the +*host* and *path* components can contain the wildcard character (@*@) to +represent zero or more other characters. + +/Since: 2.6/ +-} +userScriptNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@source@/: Source code of the user script. -} + -> WebKit2.Enums.UserContentInjectedFrames + {- ^ /@injectedFrames@/: A 'GI.WebKit2.Enums.UserContentInjectedFrames' value -} + -> WebKit2.Enums.UserScriptInjectionTime + {- ^ /@injectionTime@/: A 'GI.WebKit2.Enums.UserScriptInjectionTime' value -} + -> Maybe ([T.Text]) + {- ^ /@whitelist@/: A whitelist of URI patterns or 'Nothing' -} + -> Maybe ([T.Text]) + {- ^ /@blacklist@/: A blacklist of URI patterns or 'Nothing' -} + -> m UserScript + {- ^ __Returns:__ A new 'GI.WebKit2.Structs.UserScript.UserScript' -} +userScriptNew source injectedFrames injectionTime whitelist blacklist = liftIO $ do + source' <- textToCString source + let injectedFrames' = (fromIntegral . fromEnum) injectedFrames + let injectionTime' = (fromIntegral . fromEnum) injectionTime + maybeWhitelist <- case whitelist of + Nothing -> return nullPtr + Just jWhitelist -> do + jWhitelist' <- packZeroTerminatedUTF8CArray jWhitelist + return jWhitelist' + maybeBlacklist <- case blacklist of + Nothing -> return nullPtr + Just jBlacklist -> do + jBlacklist' <- packZeroTerminatedUTF8CArray jBlacklist + return jBlacklist' + result <- webkit_user_script_new source' injectedFrames' injectionTime' maybeWhitelist maybeBlacklist + checkUnexpectedReturnNULL "userScriptNew" result + result' <- (wrapBoxed UserScript) result + freeMem source' + mapZeroTerminatedCArray freeMem maybeWhitelist + freeMem maybeWhitelist + mapZeroTerminatedCArray freeMem maybeBlacklist + freeMem maybeBlacklist + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserScript::new_for_world +-- method type : Constructor +-- Args : [Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source code of the user script.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injected_frames", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentInjectedFrames value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injection_time", argType = TInterface (Name {namespace = "WebKit2", name = "UserScriptInjectionTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserScriptInjectionTime value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "world_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a #WebKitScriptWorld", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whitelist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A whitelist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blacklist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A blacklist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserScript"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_script_new_for_world" webkit_user_script_new_for_world :: + CString -> -- source : TBasicType TUTF8 + CUInt -> -- injected_frames : TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}) + CUInt -> -- injection_time : TInterface (Name {namespace = "WebKit2", name = "UserScriptInjectionTime"}) + CString -> -- world_name : TBasicType TUTF8 + Ptr CString -> -- whitelist : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr CString -> -- blacklist : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr UserScript) + +{- | +Creates a new user script for script world with name /@worldName@/. +See 'GI.WebKit2.Structs.UserScript.userScriptNew' for a full description. + +/Since: 2.22/ +-} +userScriptNewForWorld :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@source@/: Source code of the user script. -} + -> WebKit2.Enums.UserContentInjectedFrames + {- ^ /@injectedFrames@/: A 'GI.WebKit2.Enums.UserContentInjectedFrames' value -} + -> WebKit2.Enums.UserScriptInjectionTime + {- ^ /@injectionTime@/: A 'GI.WebKit2.Enums.UserScriptInjectionTime' value -} + -> T.Text + {- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@ -} + -> Maybe ([T.Text]) + {- ^ /@whitelist@/: A whitelist of URI patterns or 'Nothing' -} + -> Maybe ([T.Text]) + {- ^ /@blacklist@/: A blacklist of URI patterns or 'Nothing' -} + -> m UserScript + {- ^ __Returns:__ A new 'GI.WebKit2.Structs.UserScript.UserScript' -} +userScriptNewForWorld source injectedFrames injectionTime worldName whitelist blacklist = liftIO $ do + source' <- textToCString source + let injectedFrames' = (fromIntegral . fromEnum) injectedFrames + let injectionTime' = (fromIntegral . fromEnum) injectionTime + worldName' <- textToCString worldName + maybeWhitelist <- case whitelist of + Nothing -> return nullPtr + Just jWhitelist -> do + jWhitelist' <- packZeroTerminatedUTF8CArray jWhitelist + return jWhitelist' + maybeBlacklist <- case blacklist of + Nothing -> return nullPtr + Just jBlacklist -> do + jBlacklist' <- packZeroTerminatedUTF8CArray jBlacklist + return jBlacklist' + result <- webkit_user_script_new_for_world source' injectedFrames' injectionTime' worldName' maybeWhitelist maybeBlacklist + checkUnexpectedReturnNULL "userScriptNewForWorld" result + result' <- (wrapBoxed UserScript) result + freeMem source' + freeMem worldName' + mapZeroTerminatedCArray freeMem maybeWhitelist + freeMem maybeWhitelist + mapZeroTerminatedCArray freeMem maybeBlacklist + freeMem maybeBlacklist + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserScript::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_script", argType = TInterface (Name {namespace = "WebKit2", name = "UserScript"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserScript", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserScript"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_script_ref" webkit_user_script_ref :: + Ptr UserScript -> -- user_script : TInterface (Name {namespace = "WebKit2", name = "UserScript"}) + IO (Ptr UserScript) + +{- | +Atomically increments the reference count of /@userScript@/ by one. +This function is MT-safe and may be called from any thread. + +/Since: 2.6/ +-} +userScriptRef :: + (B.CallStack.HasCallStack, MonadIO m) => + UserScript + {- ^ /@userScript@/: a 'GI.WebKit2.Structs.UserScript.UserScript' -} + -> m UserScript + {- ^ __Returns:__ The passed 'GI.WebKit2.Structs.UserScript.UserScript' -} +userScriptRef userScript = liftIO $ do + userScript' <- unsafeManagedPtrGetPtr userScript + result <- webkit_user_script_ref userScript' + checkUnexpectedReturnNULL "userScriptRef" result + result' <- (wrapBoxed UserScript) result + touchManagedPtr userScript + return result' + +#if ENABLE_OVERLOADING +data UserScriptRefMethodInfo +instance (signature ~ (m UserScript), MonadIO m) => O.MethodInfo UserScriptRefMethodInfo UserScript signature where + overloadedMethod _ = userScriptRef + +#endif + +-- method UserScript::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_script", argType = TInterface (Name {namespace = "WebKit2", name = "UserScript"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserScript", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_script_unref" webkit_user_script_unref :: + Ptr UserScript -> -- user_script : TInterface (Name {namespace = "WebKit2", name = "UserScript"}) + IO () + +{- | +Atomically decrements the reference count of /@userScript@/ by one. +If the reference count drops to 0, all memory allocated by +'GI.WebKit2.Structs.UserScript.UserScript' is released. This function is MT-safe and may be called +from any thread. + +/Since: 2.6/ +-} +userScriptUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + UserScript + {- ^ /@userScript@/: a 'GI.WebKit2.Structs.UserScript.UserScript' -} + -> m () +userScriptUnref userScript = liftIO $ do + userScript' <- unsafeManagedPtrGetPtr userScript + webkit_user_script_unref userScript' + touchManagedPtr userScript + return () + +#if ENABLE_OVERLOADING +data UserScriptUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo UserScriptUnrefMethodInfo UserScript signature where + overloadedMethod _ = userScriptUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveUserScriptMethod (t :: Symbol) (o :: *) :: * where + ResolveUserScriptMethod "ref" o = UserScriptRefMethodInfo + ResolveUserScriptMethod "unref" o = UserScriptUnrefMethodInfo + ResolveUserScriptMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserScriptMethod t UserScript, O.MethodInfo info UserScript p) => OL.IsLabel t (UserScript -> 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 + + diff --git a/GI/WebKit2/Structs/UserScript.hs-boot b/GI/WebKit2/Structs/UserScript.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserScript.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.UserScript 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 + +newtype UserScript = UserScript (ManagedPtr UserScript) +instance BoxedObject UserScript where +#if ENABLE_OVERLOADING +data UserScriptRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserScriptUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/UserStyleSheet.hs b/GI/WebKit2/Structs/UserStyleSheet.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserStyleSheet.hs @@ -0,0 +1,322 @@ + + +{- | +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.Structs.UserStyleSheet + ( + +-- * Exported types + UserStyleSheet(..) , + noUserStyleSheet , + + + -- * Methods +-- ** new #method:new# + + userStyleSheetNew , + + +-- ** newForWorld #method:newForWorld# + + userStyleSheetNewForWorld , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + UserStyleSheetRefMethodInfo , +#endif + userStyleSheetRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + UserStyleSheetUnrefMethodInfo , +#endif + userStyleSheetUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums + +-- | Memory-managed wrapper type. +newtype UserStyleSheet = UserStyleSheet (ManagedPtr UserStyleSheet) +foreign import ccall "webkit_user_style_sheet_get_type" c_webkit_user_style_sheet_get_type :: + IO GType + +instance BoxedObject UserStyleSheet where + boxedType _ = c_webkit_user_style_sheet_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `UserStyleSheet`. +noUserStyleSheet :: Maybe UserStyleSheet +noUserStyleSheet = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UserStyleSheet +type instance O.AttributeList UserStyleSheet = UserStyleSheetAttributeList +type UserStyleSheetAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method UserStyleSheet::new +-- method type : Constructor +-- Args : [Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source code of the user style sheet.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injected_frames", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentInjectedFrames value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface (Name {namespace = "WebKit2", name = "UserStyleLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserStyleLevel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whitelist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A whitelist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blacklist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A blacklist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_style_sheet_new" webkit_user_style_sheet_new :: + CString -> -- source : TBasicType TUTF8 + CUInt -> -- injected_frames : TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}) + CUInt -> -- level : TInterface (Name {namespace = "WebKit2", name = "UserStyleLevel"}) + Ptr CString -> -- whitelist : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr CString -> -- blacklist : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr UserStyleSheet) + +{- | +Creates a new user style sheet. Style sheets can be applied to some URIs +only by passing non-null values for /@whitelist@/ or /@blacklist@/. Passing a +'Nothing' whitelist implies that all URIs are on the whitelist. The style +sheet is applied if an URI matches the whitelist and not the blacklist. +URI patterns must be of the form @[protocol]:\/\/[host]\/[path]@, where the +*host* and *path* components can contain the wildcard character (@*@) to +represent zero or more other characters. + +/Since: 2.6/ +-} +userStyleSheetNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@source@/: Source code of the user style sheet. -} + -> WebKit2.Enums.UserContentInjectedFrames + {- ^ /@injectedFrames@/: A 'GI.WebKit2.Enums.UserContentInjectedFrames' value -} + -> WebKit2.Enums.UserStyleLevel + {- ^ /@level@/: A 'GI.WebKit2.Enums.UserStyleLevel' -} + -> Maybe ([T.Text]) + {- ^ /@whitelist@/: A whitelist of URI patterns or 'Nothing' -} + -> Maybe ([T.Text]) + {- ^ /@blacklist@/: A blacklist of URI patterns or 'Nothing' -} + -> m UserStyleSheet + {- ^ __Returns:__ A new 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} +userStyleSheetNew source injectedFrames level whitelist blacklist = liftIO $ do + source' <- textToCString source + let injectedFrames' = (fromIntegral . fromEnum) injectedFrames + let level' = (fromIntegral . fromEnum) level + maybeWhitelist <- case whitelist of + Nothing -> return nullPtr + Just jWhitelist -> do + jWhitelist' <- packZeroTerminatedUTF8CArray jWhitelist + return jWhitelist' + maybeBlacklist <- case blacklist of + Nothing -> return nullPtr + Just jBlacklist -> do + jBlacklist' <- packZeroTerminatedUTF8CArray jBlacklist + return jBlacklist' + result <- webkit_user_style_sheet_new source' injectedFrames' level' maybeWhitelist maybeBlacklist + checkUnexpectedReturnNULL "userStyleSheetNew" result + result' <- (wrapBoxed UserStyleSheet) result + freeMem source' + mapZeroTerminatedCArray freeMem maybeWhitelist + freeMem maybeWhitelist + mapZeroTerminatedCArray freeMem maybeBlacklist + freeMem maybeBlacklist + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserStyleSheet::new_for_world +-- method type : Constructor +-- Args : [Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source code of the user style sheet.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "injected_frames", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserContentInjectedFrames value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface (Name {namespace = "WebKit2", name = "UserStyleLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitUserStyleLevel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "world_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a #WebKitScriptWorld", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "whitelist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A whitelist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blacklist", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A blacklist of URI patterns or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_style_sheet_new_for_world" webkit_user_style_sheet_new_for_world :: + CString -> -- source : TBasicType TUTF8 + CUInt -> -- injected_frames : TInterface (Name {namespace = "WebKit2", name = "UserContentInjectedFrames"}) + CUInt -> -- level : TInterface (Name {namespace = "WebKit2", name = "UserStyleLevel"}) + CString -> -- world_name : TBasicType TUTF8 + Ptr CString -> -- whitelist : TCArray True (-1) (-1) (TBasicType TUTF8) + Ptr CString -> -- blacklist : TCArray True (-1) (-1) (TBasicType TUTF8) + IO (Ptr UserStyleSheet) + +{- | +Creates a new user style sheet for script world with name /@worldName@/. +See 'GI.WebKit2.Structs.UserStyleSheet.userStyleSheetNew' for a full description. + +/Since: 2.22/ +-} +userStyleSheetNewForWorld :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@source@/: Source code of the user style sheet. -} + -> WebKit2.Enums.UserContentInjectedFrames + {- ^ /@injectedFrames@/: A 'GI.WebKit2.Enums.UserContentInjectedFrames' value -} + -> WebKit2.Enums.UserStyleLevel + {- ^ /@level@/: A 'GI.WebKit2.Enums.UserStyleLevel' -} + -> T.Text + {- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@ -} + -> Maybe ([T.Text]) + {- ^ /@whitelist@/: A whitelist of URI patterns or 'Nothing' -} + -> Maybe ([T.Text]) + {- ^ /@blacklist@/: A blacklist of URI patterns or 'Nothing' -} + -> m UserStyleSheet + {- ^ __Returns:__ A new 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} +userStyleSheetNewForWorld source injectedFrames level worldName whitelist blacklist = liftIO $ do + source' <- textToCString source + let injectedFrames' = (fromIntegral . fromEnum) injectedFrames + let level' = (fromIntegral . fromEnum) level + worldName' <- textToCString worldName + maybeWhitelist <- case whitelist of + Nothing -> return nullPtr + Just jWhitelist -> do + jWhitelist' <- packZeroTerminatedUTF8CArray jWhitelist + return jWhitelist' + maybeBlacklist <- case blacklist of + Nothing -> return nullPtr + Just jBlacklist -> do + jBlacklist' <- packZeroTerminatedUTF8CArray jBlacklist + return jBlacklist' + result <- webkit_user_style_sheet_new_for_world source' injectedFrames' level' worldName' maybeWhitelist maybeBlacklist + checkUnexpectedReturnNULL "userStyleSheetNewForWorld" result + result' <- (wrapBoxed UserStyleSheet) result + freeMem source' + freeMem worldName' + mapZeroTerminatedCArray freeMem maybeWhitelist + freeMem maybeWhitelist + mapZeroTerminatedCArray freeMem maybeBlacklist + freeMem maybeBlacklist + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method UserStyleSheet::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_style_sheet", argType = TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserStyleSheet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_style_sheet_ref" webkit_user_style_sheet_ref :: + Ptr UserStyleSheet -> -- user_style_sheet : TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}) + IO (Ptr UserStyleSheet) + +{- | +Atomically increments the reference count of /@userStyleSheet@/ by one. +This function is MT-safe and may be called from any thread. + +/Since: 2.6/ +-} +userStyleSheetRef :: + (B.CallStack.HasCallStack, MonadIO m) => + UserStyleSheet + {- ^ /@userStyleSheet@/: a 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} + -> m UserStyleSheet + {- ^ __Returns:__ The passed 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} +userStyleSheetRef userStyleSheet = liftIO $ do + userStyleSheet' <- unsafeManagedPtrGetPtr userStyleSheet + result <- webkit_user_style_sheet_ref userStyleSheet' + checkUnexpectedReturnNULL "userStyleSheetRef" result + result' <- (wrapBoxed UserStyleSheet) result + touchManagedPtr userStyleSheet + return result' + +#if ENABLE_OVERLOADING +data UserStyleSheetRefMethodInfo +instance (signature ~ (m UserStyleSheet), MonadIO m) => O.MethodInfo UserStyleSheetRefMethodInfo UserStyleSheet signature where + overloadedMethod _ = userStyleSheetRef + +#endif + +-- method UserStyleSheet::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "user_style_sheet", argType = TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserStyleSheet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_user_style_sheet_unref" webkit_user_style_sheet_unref :: + Ptr UserStyleSheet -> -- user_style_sheet : TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"}) + IO () + +{- | +Atomically decrements the reference count of /@userStyleSheet@/ by one. +If the reference count drops to 0, all memory allocated by +'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' is released. This function is MT-safe and may be +called from any thread. + +/Since: 2.6/ +-} +userStyleSheetUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + UserStyleSheet + {- ^ /@userStyleSheet@/: a 'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' -} + -> m () +userStyleSheetUnref userStyleSheet = liftIO $ do + userStyleSheet' <- unsafeManagedPtrGetPtr userStyleSheet + webkit_user_style_sheet_unref userStyleSheet' + touchManagedPtr userStyleSheet + return () + +#if ENABLE_OVERLOADING +data UserStyleSheetUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo UserStyleSheetUnrefMethodInfo UserStyleSheet signature where + overloadedMethod _ = userStyleSheetUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveUserStyleSheetMethod (t :: Symbol) (o :: *) :: * where + ResolveUserStyleSheetMethod "ref" o = UserStyleSheetRefMethodInfo + ResolveUserStyleSheetMethod "unref" o = UserStyleSheetUnrefMethodInfo + ResolveUserStyleSheetMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUserStyleSheetMethod t UserStyleSheet, O.MethodInfo info UserStyleSheet p) => OL.IsLabel t (UserStyleSheet -> 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 + + diff --git a/GI/WebKit2/Structs/UserStyleSheet.hs-boot b/GI/WebKit2/Structs/UserStyleSheet.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/UserStyleSheet.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.UserStyleSheet 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 + +newtype UserStyleSheet = UserStyleSheet (ManagedPtr UserStyleSheet) +instance BoxedObject UserStyleSheet where +#if ENABLE_OVERLOADING +data UserStyleSheetRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data UserStyleSheetUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/WebViewSessionState.hs b/GI/WebKit2/Structs/WebViewSessionState.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/WebViewSessionState.hs @@ -0,0 +1,262 @@ + + +{- | +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.Structs.WebViewSessionState + ( + +-- * Exported types + WebViewSessionState(..) , + noWebViewSessionState , + + + -- * Methods +-- ** new #method:new# + + webViewSessionStateNew , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + WebViewSessionStateRefMethodInfo , +#endif + webViewSessionStateRef , + + +-- ** serialize #method:serialize# + +#if ENABLE_OVERLOADING + WebViewSessionStateSerializeMethodInfo , +#endif + webViewSessionStateSerialize , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + WebViewSessionStateUnrefMethodInfo , +#endif + webViewSessionStateUnref , + + + + + ) 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.GLib.Structs.Bytes as GLib.Bytes + +-- | Memory-managed wrapper type. +newtype WebViewSessionState = WebViewSessionState (ManagedPtr WebViewSessionState) +foreign import ccall "webkit_web_view_session_state_get_type" c_webkit_web_view_session_state_get_type :: + IO GType + +instance BoxedObject WebViewSessionState where + boxedType _ = c_webkit_web_view_session_state_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `WebViewSessionState`. +noWebViewSessionState :: Maybe WebViewSessionState +noWebViewSessionState = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebViewSessionState +type instance O.AttributeList WebViewSessionState = WebViewSessionStateAttributeList +type WebViewSessionStateAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method WebViewSessionState::new +-- method type : Constructor +-- Args : [Arg {argCName = "data", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_session_state_new" webkit_web_view_session_state_new :: + Ptr GLib.Bytes.Bytes -> -- data : TInterface (Name {namespace = "GLib", name = "Bytes"}) + IO (Ptr WebViewSessionState) + +{- | +Creates a new 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' from serialized data. + +/Since: 2.12/ +-} +webViewSessionStateNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GLib.Bytes.Bytes + {- ^ /@data@/: a 'GI.GLib.Structs.Bytes.Bytes' -} + -> m WebViewSessionState + {- ^ __Returns:__ a new 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState', or 'Nothing' if /@data@/ doesn\'t contain a + valid serialized 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState'. -} +webViewSessionStateNew data_ = liftIO $ do + data_' <- unsafeManagedPtrGetPtr data_ + result <- webkit_web_view_session_state_new data_' + checkUnexpectedReturnNULL "webViewSessionStateNew" result + result' <- (wrapBoxed WebViewSessionState) result + touchManagedPtr data_ + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method WebViewSessionState::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebViewSessionState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_session_state_ref" webkit_web_view_session_state_ref :: + Ptr WebViewSessionState -> -- state : TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}) + IO (Ptr WebViewSessionState) + +{- | +Atomically increments the reference count of /@state@/ by one. This +function is MT-safe and may be called from any thread. + +/Since: 2.12/ +-} +webViewSessionStateRef :: + (B.CallStack.HasCallStack, MonadIO m) => + WebViewSessionState + {- ^ /@state@/: a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} + -> m WebViewSessionState + {- ^ __Returns:__ The passed in 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} +webViewSessionStateRef state = liftIO $ do + state' <- unsafeManagedPtrGetPtr state + result <- webkit_web_view_session_state_ref state' + checkUnexpectedReturnNULL "webViewSessionStateRef" result + result' <- (wrapBoxed WebViewSessionState) result + touchManagedPtr state + return result' + +#if ENABLE_OVERLOADING +data WebViewSessionStateRefMethodInfo +instance (signature ~ (m WebViewSessionState), MonadIO m) => O.MethodInfo WebViewSessionStateRefMethodInfo WebViewSessionState signature where + overloadedMethod _ = webViewSessionStateRef + +#endif + +-- method WebViewSessionState::serialize +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebViewSessionState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Bytes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_web_view_session_state_serialize" webkit_web_view_session_state_serialize :: + Ptr WebViewSessionState -> -- state : TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}) + IO (Ptr GLib.Bytes.Bytes) + +{- | +Serializes a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState'. + +/Since: 2.12/ +-} +webViewSessionStateSerialize :: + (B.CallStack.HasCallStack, MonadIO m) => + WebViewSessionState + {- ^ /@state@/: a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} + -> m GLib.Bytes.Bytes + {- ^ __Returns:__ a 'GI.GLib.Structs.Bytes.Bytes' containing the /@state@/ serialized. -} +webViewSessionStateSerialize state = liftIO $ do + state' <- unsafeManagedPtrGetPtr state + result <- webkit_web_view_session_state_serialize state' + checkUnexpectedReturnNULL "webViewSessionStateSerialize" result + result' <- (wrapBoxed GLib.Bytes.Bytes) result + touchManagedPtr state + return result' + +#if ENABLE_OVERLOADING +data WebViewSessionStateSerializeMethodInfo +instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m) => O.MethodInfo WebViewSessionStateSerializeMethodInfo WebViewSessionState signature where + overloadedMethod _ = webViewSessionStateSerialize + +#endif + +-- method WebViewSessionState::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebViewSessionState", 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_view_session_state_unref" webkit_web_view_session_state_unref :: + Ptr WebViewSessionState -> -- state : TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}) + IO () + +{- | +Atomically decrements the reference count of /@state@/ by one. If the +reference count drops to 0, all memory allocated by the 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' is +released. This function is MT-safe and may be called from any thread. + +/Since: 2.12/ +-} +webViewSessionStateUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + WebViewSessionState + {- ^ /@state@/: a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -} + -> m () +webViewSessionStateUnref state = liftIO $ do + state' <- unsafeManagedPtrGetPtr state + webkit_web_view_session_state_unref state' + touchManagedPtr state + return () + +#if ENABLE_OVERLOADING +data WebViewSessionStateUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo WebViewSessionStateUnrefMethodInfo WebViewSessionState signature where + overloadedMethod _ = webViewSessionStateUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveWebViewSessionStateMethod (t :: Symbol) (o :: *) :: * where + ResolveWebViewSessionStateMethod "ref" o = WebViewSessionStateRefMethodInfo + ResolveWebViewSessionStateMethod "serialize" o = WebViewSessionStateSerializeMethodInfo + ResolveWebViewSessionStateMethod "unref" o = WebViewSessionStateUnrefMethodInfo + ResolveWebViewSessionStateMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebViewSessionStateMethod t WebViewSessionState, O.MethodInfo info WebViewSessionState p) => OL.IsLabel t (WebViewSessionState -> 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 + + diff --git a/GI/WebKit2/Structs/WebViewSessionState.hs-boot b/GI/WebKit2/Structs/WebViewSessionState.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/WebViewSessionState.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.WebViewSessionState 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 + +newtype WebViewSessionState = WebViewSessionState (ManagedPtr WebViewSessionState) +instance BoxedObject WebViewSessionState where +#if ENABLE_OVERLOADING +data WebViewSessionStateRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSessionStateSerializeMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebViewSessionStateUnrefMethodInfo +#endif diff --git a/GI/WebKit2/Structs/WebsiteData.hs b/GI/WebKit2/Structs/WebsiteData.hs new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/WebsiteData.hs @@ -0,0 +1,323 @@ + + +{- | +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.Structs.WebsiteData + ( + +-- * Exported types + WebsiteData(..) , + noWebsiteData , + + + -- * Methods +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + WebsiteDataGetNameMethodInfo , +#endif + websiteDataGetName , + + +-- ** getSize #method:getSize# + +#if ENABLE_OVERLOADING + WebsiteDataGetSizeMethodInfo , +#endif + websiteDataGetSize , + + +-- ** getTypes #method:getTypes# + +#if ENABLE_OVERLOADING + WebsiteDataGetTypesMethodInfo , +#endif + websiteDataGetTypes , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + WebsiteDataRefMethodInfo , +#endif + websiteDataRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + WebsiteDataUnrefMethodInfo , +#endif + websiteDataUnref , + + + + + ) 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 {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags + +-- | Memory-managed wrapper type. +newtype WebsiteData = WebsiteData (ManagedPtr WebsiteData) +foreign import ccall "webkit_website_data_get_type" c_webkit_website_data_get_type :: + IO GType + +instance BoxedObject WebsiteData where + boxedType _ = c_webkit_website_data_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `WebsiteData`. +noWebsiteData :: Maybe WebsiteData +noWebsiteData = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList WebsiteData +type instance O.AttributeList WebsiteData = WebsiteDataAttributeList +type WebsiteDataAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method WebsiteData::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "website_data", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteData", 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_website_data_get_name" webkit_website_data_get_name :: + Ptr WebsiteData -> -- website_data : TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}) + IO CString + +{- | +Gets the name of 'GI.WebKit2.Structs.WebsiteData.WebsiteData'. This is the website name, normally represented by +a domain or host name. All local documents are grouped in the same 'GI.WebKit2.Structs.WebsiteData.WebsiteData' using +the name \"Local files\". + +/Since: 2.16/ +-} +websiteDataGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + WebsiteData + {- ^ /@websiteData@/: a 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> m T.Text + {- ^ __Returns:__ the website name of /@websiteData@/. -} +websiteDataGetName websiteData = liftIO $ do + websiteData' <- unsafeManagedPtrGetPtr websiteData + result <- webkit_website_data_get_name websiteData' + checkUnexpectedReturnNULL "websiteDataGetName" result + result' <- cstringToText result + touchManagedPtr websiteData + return result' + +#if ENABLE_OVERLOADING +data WebsiteDataGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo WebsiteDataGetNameMethodInfo WebsiteData signature where + overloadedMethod _ = websiteDataGetName + +#endif + +-- method WebsiteData::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "website_data", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteData", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask of #WebKitWebsiteDataTypes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_get_size" webkit_website_data_get_size :: + Ptr WebsiteData -> -- website_data : TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}) + CUInt -> -- types : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"}) + IO Word64 + +{- | +Gets the size of the data of types /@types@/ in a 'GI.WebKit2.Structs.WebsiteData.WebsiteData'. +Note that currently the data size is only known for 'GI.WebKit2.Flags.WebsiteDataTypesDiskCache' data type +so for all other types 0 will be returned. + +/Since: 2.16/ +-} +websiteDataGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + WebsiteData + {- ^ /@websiteData@/: a 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> [WebKit2.Flags.WebsiteDataTypes] + {- ^ /@types@/: a bitmask of 'GI.WebKit2.Flags.WebsiteDataTypes' -} + -> m Word64 + {- ^ __Returns:__ the size of /@websiteData@/ for the given /@types@/. -} +websiteDataGetSize websiteData types = liftIO $ do + websiteData' <- unsafeManagedPtrGetPtr websiteData + let types' = gflagsToWord types + result <- webkit_website_data_get_size websiteData' types' + touchManagedPtr websiteData + return result + +#if ENABLE_OVERLOADING +data WebsiteDataGetSizeMethodInfo +instance (signature ~ ([WebKit2.Flags.WebsiteDataTypes] -> m Word64), MonadIO m) => O.MethodInfo WebsiteDataGetSizeMethodInfo WebsiteData signature where + overloadedMethod _ = websiteDataGetSize + +#endif + +-- method WebsiteData::get_types +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "website_data", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteData", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteDataTypes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_get_types" webkit_website_data_get_types :: + Ptr WebsiteData -> -- website_data : TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}) + IO CUInt + +{- | +Gets the types of data stored in the client for a 'GI.WebKit2.Structs.WebsiteData.WebsiteData'. These are the +types actually present, not the types queried with 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerFetch'. + +/Since: 2.16/ +-} +websiteDataGetTypes :: + (B.CallStack.HasCallStack, MonadIO m) => + WebsiteData + {- ^ /@websiteData@/: a 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> m [WebKit2.Flags.WebsiteDataTypes] + {- ^ __Returns:__ a bitmask of 'GI.WebKit2.Flags.WebsiteDataTypes' in /@websiteData@/ -} +websiteDataGetTypes websiteData = liftIO $ do + websiteData' <- unsafeManagedPtrGetPtr websiteData + result <- webkit_website_data_get_types websiteData' + let result' = wordToGFlags result + touchManagedPtr websiteData + return result' + +#if ENABLE_OVERLOADING +data WebsiteDataGetTypesMethodInfo +instance (signature ~ (m [WebKit2.Flags.WebsiteDataTypes]), MonadIO m) => O.MethodInfo WebsiteDataGetTypesMethodInfo WebsiteData signature where + overloadedMethod _ = websiteDataGetTypes + +#endif + +-- method WebsiteData::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "website_data", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteData", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteData"})) +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_ref" webkit_website_data_ref :: + Ptr WebsiteData -> -- website_data : TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}) + IO (Ptr WebsiteData) + +{- | +Atomically increments the reference count of /@websiteData@/ by one. +This function is MT-safe and may be called from any thread. + +/Since: 2.16/ +-} +websiteDataRef :: + (B.CallStack.HasCallStack, MonadIO m) => + WebsiteData + {- ^ /@websiteData@/: a 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> m WebsiteData + {- ^ __Returns:__ The passed 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} +websiteDataRef websiteData = liftIO $ do + websiteData' <- unsafeManagedPtrGetPtr websiteData + result <- webkit_website_data_ref websiteData' + checkUnexpectedReturnNULL "websiteDataRef" result + result' <- (wrapBoxed WebsiteData) result + touchManagedPtr websiteData + return result' + +#if ENABLE_OVERLOADING +data WebsiteDataRefMethodInfo +instance (signature ~ (m WebsiteData), MonadIO m) => O.MethodInfo WebsiteDataRefMethodInfo WebsiteData signature where + overloadedMethod _ = websiteDataRef + +#endif + +-- method WebsiteData::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "website_data", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitWebsiteData", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "webkit_website_data_unref" webkit_website_data_unref :: + Ptr WebsiteData -> -- website_data : TInterface (Name {namespace = "WebKit2", name = "WebsiteData"}) + IO () + +{- | +Atomically decrements the reference count of /@websiteData@/ by one. +If the reference count drops to 0, all memory allocated by +'GI.WebKit2.Structs.WebsiteData.WebsiteData' is released. This function is MT-safe and may be +called from any thread. + +/Since: 2.16/ +-} +websiteDataUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + WebsiteData + {- ^ /@websiteData@/: A 'GI.WebKit2.Structs.WebsiteData.WebsiteData' -} + -> m () +websiteDataUnref websiteData = liftIO $ do + websiteData' <- unsafeManagedPtrGetPtr websiteData + webkit_website_data_unref websiteData' + touchManagedPtr websiteData + return () + +#if ENABLE_OVERLOADING +data WebsiteDataUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo WebsiteDataUnrefMethodInfo WebsiteData signature where + overloadedMethod _ = websiteDataUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveWebsiteDataMethod (t :: Symbol) (o :: *) :: * where + ResolveWebsiteDataMethod "ref" o = WebsiteDataRefMethodInfo + ResolveWebsiteDataMethod "unref" o = WebsiteDataUnrefMethodInfo + ResolveWebsiteDataMethod "getName" o = WebsiteDataGetNameMethodInfo + ResolveWebsiteDataMethod "getSize" o = WebsiteDataGetSizeMethodInfo + ResolveWebsiteDataMethod "getTypes" o = WebsiteDataGetTypesMethodInfo + ResolveWebsiteDataMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveWebsiteDataMethod t WebsiteData, O.MethodInfo info WebsiteData p) => OL.IsLabel t (WebsiteData -> 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 + + diff --git a/GI/WebKit2/Structs/WebsiteData.hs-boot b/GI/WebKit2/Structs/WebsiteData.hs-boot new file mode 100644 --- /dev/null +++ b/GI/WebKit2/Structs/WebsiteData.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.WebKit2.Structs.WebsiteData 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 + +newtype WebsiteData = WebsiteData (ManagedPtr WebsiteData) +instance BoxedObject WebsiteData where +#if ENABLE_OVERLOADING +data WebsiteDataGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataGetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataGetTypesMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data WebsiteDataUnrefMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-webkit2 library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-webkit2 library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-webkit2 libraries, or to link their applications against a +user-supplied version of gi-webkit2. If you link applications to a modified +version of gi-webkit2, then the changes to gi-webkit2 must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-webkit2-4.0.19/docs/GI-WebKit2.html](https://hackage.haskell.org/package/gi-webkit2-4.0.19/docs/GI-WebKit2.html) +[https://hackage.haskell.org/package/gi-webkit2-4.0.21/docs/GI-WebKit2.html](https://hackage.haskell.org/package/gi-webkit2-4.0.21/docs/GI-WebKit2.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/WebKit2.overrides b/WebKit2.overrides --- a/WebKit2.overrides +++ b/WebKit2.overrides @@ -23,6 +23,10 @@ set-attr WebKit2/NetworkProxySettings/new/@parameters/ignore_hosts/@array/@type name utf8 set-attr WebKit2/NetworkProxySettings/new/@parameters/ignore_hosts/@array/@type c:type gchar** +# In older versions this parameter had type "gpointer", which was +# corrected later. +set-attr WebKit2/WebView/load-failed/@parameters/error/@type name GLib.Error + # https://github.com/haskell-gi/haskell-gi/issues/155 # Even get_current_item can return null if no page has ever been loaded set-attr WebKit2/BackForwardList/get_current_item/@return-value nullable 1 diff --git a/gi-webkit2.cabal b/gi-webkit2.cabal --- a/gi-webkit2.cabal +++ b/gi-webkit2.cabal @@ -1,12 +1,12 @@ name: gi-webkit2 -version: 4.0.19 +version: 4.0.21 synopsis: WebKit2 bindings description: Bindings for WebKit2, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom cabal-version: 1.24 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml WebKit2.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: webkit2gtk-4.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-cairo == 1.0.*, gi-soup == 2.4.*, @@ -47,3 +47,70 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.WebKit2, + GI.WebKit2.Callbacks, + GI.WebKit2.Constants, + GI.WebKit2.Enums, + GI.WebKit2.Flags, + GI.WebKit2.Functions, + GI.WebKit2.Interfaces, + GI.WebKit2.Interfaces.PermissionRequest, + GI.WebKit2.Objects, + GI.WebKit2.Objects.AuthenticationRequest, + GI.WebKit2.Objects.AutomationSession, + GI.WebKit2.Objects.BackForwardList, + GI.WebKit2.Objects.BackForwardListItem, + GI.WebKit2.Objects.ColorChooserRequest, + GI.WebKit2.Objects.ContextMenu, + GI.WebKit2.Objects.ContextMenuItem, + GI.WebKit2.Objects.CookieManager, + GI.WebKit2.Objects.DeviceInfoPermissionRequest, + GI.WebKit2.Objects.Download, + GI.WebKit2.Objects.EditorState, + GI.WebKit2.Objects.FaviconDatabase, + GI.WebKit2.Objects.FileChooserRequest, + GI.WebKit2.Objects.FindController, + GI.WebKit2.Objects.FormSubmissionRequest, + GI.WebKit2.Objects.GeolocationPermissionRequest, + GI.WebKit2.Objects.HitTestResult, + GI.WebKit2.Objects.InstallMissingMediaPluginsPermissionRequest, + GI.WebKit2.Objects.NavigationPolicyDecision, + GI.WebKit2.Objects.Notification, + GI.WebKit2.Objects.NotificationPermissionRequest, + GI.WebKit2.Objects.OptionMenu, + GI.WebKit2.Objects.Plugin, + GI.WebKit2.Objects.PolicyDecision, + GI.WebKit2.Objects.PrintCustomWidget, + GI.WebKit2.Objects.PrintOperation, + GI.WebKit2.Objects.ResponsePolicyDecision, + GI.WebKit2.Objects.SecurityManager, + GI.WebKit2.Objects.Settings, + GI.WebKit2.Objects.URIRequest, + GI.WebKit2.Objects.URIResponse, + GI.WebKit2.Objects.URISchemeRequest, + GI.WebKit2.Objects.UserContentFilterStore, + GI.WebKit2.Objects.UserContentManager, + GI.WebKit2.Objects.UserMediaPermissionRequest, + GI.WebKit2.Objects.WebContext, + GI.WebKit2.Objects.WebInspector, + GI.WebKit2.Objects.WebResource, + GI.WebKit2.Objects.WebView, + GI.WebKit2.Objects.WebViewBase, + GI.WebKit2.Objects.WebsiteDataManager, + GI.WebKit2.Objects.WindowProperties, + GI.WebKit2.Structs, + GI.WebKit2.Structs.ApplicationInfo, + GI.WebKit2.Structs.Credential, + GI.WebKit2.Structs.JavascriptResult, + GI.WebKit2.Structs.MimeInfo, + GI.WebKit2.Structs.NavigationAction, + GI.WebKit2.Structs.NetworkProxySettings, + GI.WebKit2.Structs.OptionMenuItem, + GI.WebKit2.Structs.ScriptDialog, + GI.WebKit2.Structs.SecurityOrigin, + GI.WebKit2.Structs.UserContentFilter, + GI.WebKit2.Structs.UserScript, + GI.WebKit2.Structs.UserStyleSheet, + GI.WebKit2.Structs.WebViewSessionState, + GI.WebKit2.Structs.WebsiteData diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7