{-# LANGUAGE TypeApplications #-}


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

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

module GI.WebKit2.Objects.FormSubmissionRequest
    ( 

-- * Exported types
    FormSubmissionRequest(..)               ,
    IsFormSubmissionRequest                 ,
    toFormSubmissionRequest                 ,
    noFormSubmissionRequest                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveFormSubmissionRequestMethod      ,
#endif


-- ** getTextFields #method:getTextFields#

#if defined(ENABLE_OVERLOADING)
    FormSubmissionRequestGetTextFieldsMethodInfo,
#endif
    formSubmissionRequestGetTextFields      ,


-- ** listTextFields #method:listTextFields#

#if defined(ENABLE_OVERLOADING)
    FormSubmissionRequestListTextFieldsMethodInfo,
#endif
    formSubmissionRequestListTextFields     ,


-- ** submit #method:submit#

#if defined(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.GI.Base.Signals as B.Signals
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)
    deriving (FormSubmissionRequest -> FormSubmissionRequest -> Bool
(FormSubmissionRequest -> FormSubmissionRequest -> Bool)
-> (FormSubmissionRequest -> FormSubmissionRequest -> Bool)
-> Eq FormSubmissionRequest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormSubmissionRequest -> FormSubmissionRequest -> Bool
$c/= :: FormSubmissionRequest -> FormSubmissionRequest -> Bool
== :: FormSubmissionRequest -> FormSubmissionRequest -> Bool
$c== :: FormSubmissionRequest -> FormSubmissionRequest -> Bool
Eq)
foreign import ccall "webkit_form_submission_request_get_type"
    c_webkit_form_submission_request_get_type :: IO GType

instance GObject FormSubmissionRequest where
    gobjectType :: IO GType
gobjectType = IO GType
c_webkit_form_submission_request_get_type
    

-- | Convert 'FormSubmissionRequest' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue FormSubmissionRequest where
    toGValue :: FormSubmissionRequest -> IO GValue
toGValue o :: FormSubmissionRequest
o = do
        GType
gtype <- IO GType
c_webkit_form_submission_request_get_type
        FormSubmissionRequest
-> (Ptr FormSubmissionRequest -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FormSubmissionRequest
o (GType
-> (GValue -> Ptr FormSubmissionRequest -> IO ())
-> Ptr FormSubmissionRequest
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr FormSubmissionRequest -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO FormSubmissionRequest
fromGValue gv :: GValue
gv = do
        Ptr FormSubmissionRequest
ptr <- GValue -> IO (Ptr FormSubmissionRequest)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr FormSubmissionRequest)
        (ManagedPtr FormSubmissionRequest -> FormSubmissionRequest)
-> Ptr FormSubmissionRequest -> IO FormSubmissionRequest
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr FormSubmissionRequest -> FormSubmissionRequest
FormSubmissionRequest Ptr FormSubmissionRequest
ptr
        
    

-- | 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 :: o -> m FormSubmissionRequest
toFormSubmissionRequest = IO FormSubmissionRequest -> m FormSubmissionRequest
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FormSubmissionRequest -> m FormSubmissionRequest)
-> (o -> IO FormSubmissionRequest) -> o -> m FormSubmissionRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr FormSubmissionRequest -> FormSubmissionRequest)
-> o -> IO FormSubmissionRequest
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr FormSubmissionRequest -> FormSubmissionRequest
FormSubmissionRequest

-- | A convenience alias for `Nothing` :: `Maybe` `FormSubmissionRequest`.
noFormSubmissionRequest :: Maybe FormSubmissionRequest
noFormSubmissionRequest :: Maybe FormSubmissionRequest
noFormSubmissionRequest = Maybe FormSubmissionRequest
forall a. Maybe a
Nothing

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FormSubmissionRequest
type instance O.AttributeList FormSubmissionRequest = FormSubmissionRequestAttributeList
type FormSubmissionRequestAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(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 t'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 t'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest'
    -> m (Maybe (Map.Map (Ptr ()) (Ptr ())))
    -- ^ __Returns:__ a t'GI.GLib.Structs.HashTable.HashTable' with the form
    --    text fields, or 'P.Nothing' if the form doesn\'t contain text fields.
formSubmissionRequestGetTextFields :: a -> m (Maybe (Map (Ptr ()) (Ptr ())))
formSubmissionRequestGetTextFields request :: a
request = IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map (Ptr ()) (Ptr ())))
 -> m (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ do
    Ptr FormSubmissionRequest
request' <- a -> IO (Ptr FormSubmissionRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr (GHashTable (Ptr ()) (Ptr ()))
result <- Ptr FormSubmissionRequest
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
webkit_form_submission_request_get_text_fields Ptr FormSubmissionRequest
request'
    Maybe (Map (Ptr ()) (Ptr ()))
maybeResult <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
    -> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable (Ptr ()) (Ptr ()))
result ((Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO (Map (Ptr ()) (Ptr ())))
 -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
    -> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr (GHashTable (Ptr ()) (Ptr ()))
result' -> do
        [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
result'' <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
result'
        let result''' :: [(Ptr (), PtrWrapped (Ptr ()))]
result''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> [(Ptr (), PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
result''
        let result'''' :: [(Ptr (), Ptr ())]
result'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Ptr (), PtrWrapped (Ptr ()))] -> [(Ptr (), Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(Ptr (), PtrWrapped (Ptr ()))]
result'''
        let result''''' :: Map (Ptr ()) (Ptr ())
result''''' = [(Ptr (), Ptr ())] -> Map (Ptr ()) (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Ptr (), Ptr ())]
result''''
        Map (Ptr ()) (Ptr ()) -> IO (Map (Ptr ()) (Ptr ()))
forall (m :: * -> *) a. Monad m => a -> m a
return Map (Ptr ()) (Ptr ())
result'''''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Maybe (Map (Ptr ()) (Ptr ())) -> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map (Ptr ()) (Ptr ()))
maybeResult

#if defined(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
-- 'P.Nothing'.
-- 
-- If this function returns 'P.False', then both /@fieldNames@/ and
-- /@fieldValues@/ will be empty.
-- 
-- /Since: 2.20/
formSubmissionRequestListTextFields ::
    (B.CallStack.HasCallStack, MonadIO m, IsFormSubmissionRequest a) =>
    a
    -- ^ /@request@/: a t'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest'
    -> m ((Bool, [T.Text], [T.Text]))
    -- ^ __Returns:__ 'P.True' if the form contains text fields, or 'P.False' otherwise
formSubmissionRequestListTextFields :: a -> m (Bool, [Text], [Text])
formSubmissionRequestListTextFields request :: a
request = IO (Bool, [Text], [Text]) -> m (Bool, [Text], [Text])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [Text], [Text]) -> m (Bool, [Text], [Text]))
-> IO (Bool, [Text], [Text]) -> m (Bool, [Text], [Text])
forall a b. (a -> b) -> a -> b
$ do
    Ptr FormSubmissionRequest
request' <- a -> IO (Ptr FormSubmissionRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr (Ptr (GPtrArray CString))
fieldNames <- IO (Ptr (Ptr (GPtrArray CString)))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr (GPtrArray CString)))
    Ptr (Ptr (GPtrArray CString))
fieldValues <- IO (Ptr (Ptr (GPtrArray CString)))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr (GPtrArray CString)))
    CInt
result <- Ptr FormSubmissionRequest
-> Ptr (Ptr (GPtrArray CString))
-> Ptr (Ptr (GPtrArray CString))
-> IO CInt
webkit_form_submission_request_list_text_fields Ptr FormSubmissionRequest
request' Ptr (Ptr (GPtrArray CString))
fieldNames Ptr (Ptr (GPtrArray CString))
fieldValues
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    Ptr (GPtrArray CString)
fieldNames' <- Ptr (Ptr (GPtrArray CString)) -> IO (Ptr (GPtrArray CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray CString))
fieldNames
    [CString]
fieldNames'' <- Ptr (GPtrArray CString) -> IO [CString]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
fieldNames'
    [Text]
fieldNames''' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
fieldNames''
    Ptr (GPtrArray CString)
fieldValues' <- Ptr (Ptr (GPtrArray CString)) -> IO (Ptr (GPtrArray CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray CString))
fieldValues
    [CString]
fieldValues'' <- Ptr (GPtrArray CString) -> IO [CString]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
fieldValues'
    [Text]
fieldValues''' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
fieldValues''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Ptr (Ptr (GPtrArray CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
fieldNames
    Ptr (Ptr (GPtrArray CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
fieldValues
    (Bool, [Text], [Text]) -> IO (Bool, [Text], [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [Text]
fieldNames''', [Text]
fieldValues''')

#if defined(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 t'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest'
    -> m ()
formSubmissionRequestSubmit :: a -> m ()
formSubmissionRequestSubmit request :: a
request = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FormSubmissionRequest
request' <- a -> IO (Ptr FormSubmissionRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr FormSubmissionRequest -> IO ()
webkit_form_submission_request_submit Ptr FormSubmissionRequest
request'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FormSubmissionRequestSubmitMethodInfo
instance (signature ~ (m ()), MonadIO m, IsFormSubmissionRequest a) => O.MethodInfo FormSubmissionRequestSubmitMethodInfo a signature where
    overloadedMethod = formSubmissionRequestSubmit

#endif