{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A request to open a file chooser.
-- 
-- Whenever the user interacts with an \<input type=\'file\' \/>
-- HTML element, WebKit will need to show a dialog to choose one or
-- more files to be uploaded to the server along with the rest of the
-- form data. For that to happen in a general way, instead of just
-- opening a t'GI.Gtk.Objects.FileChooserDialog.FileChooserDialog' (which might be not desirable in
-- some cases, which could prefer to use their own file chooser
-- dialog), WebKit will fire the [WebView::runFileChooser]("GI.WebKit2.Objects.WebView#g:signal:runFileChooser")
-- signal with a t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' object, which will allow
-- the client application to specify the files to be selected, to
-- inspect the details of the request (e.g. if multiple selection
-- should be allowed) and to cancel the request, in case nothing was
-- selected.
-- 
-- In case the client application does not wish to handle this signal,
-- WebKit will provide a default handler which will asynchronously run
-- a regular t'GI.Gtk.Objects.FileChooserDialog.FileChooserDialog' for the user to interact with.

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

module GI.WebKit2.Objects.FileChooserRequest
    ( 

-- * Exported types
    FileChooserRequest(..)                  ,
    IsFileChooserRequest                    ,
    toFileChooserRequest                    ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [cancel]("GI.WebKit2.Objects.FileChooserRequest#g:method:cancel"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [selectFiles]("GI.WebKit2.Objects.FileChooserRequest#g:method:selectFiles"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMimeTypes]("GI.WebKit2.Objects.FileChooserRequest#g:method:getMimeTypes"), [getMimeTypesFilter]("GI.WebKit2.Objects.FileChooserRequest#g:method:getMimeTypesFilter"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSelectMultiple]("GI.WebKit2.Objects.FileChooserRequest#g:method:getSelectMultiple"), [getSelectedFiles]("GI.WebKit2.Objects.FileChooserRequest#g:method:getSelectedFiles").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveFileChooserRequestMethod         ,
#endif

-- ** cancel #method:cancel#

#if defined(ENABLE_OVERLOADING)
    FileChooserRequestCancelMethodInfo      ,
#endif
    fileChooserRequestCancel                ,


-- ** getMimeTypes #method:getMimeTypes#

#if defined(ENABLE_OVERLOADING)
    FileChooserRequestGetMimeTypesMethodInfo,
#endif
    fileChooserRequestGetMimeTypes          ,


-- ** getMimeTypesFilter #method:getMimeTypesFilter#

#if defined(ENABLE_OVERLOADING)
    FileChooserRequestGetMimeTypesFilterMethodInfo,
#endif
    fileChooserRequestGetMimeTypesFilter    ,


-- ** getSelectMultiple #method:getSelectMultiple#

#if defined(ENABLE_OVERLOADING)
    FileChooserRequestGetSelectMultipleMethodInfo,
#endif
    fileChooserRequestGetSelectMultiple     ,


-- ** getSelectedFiles #method:getSelectedFiles#

#if defined(ENABLE_OVERLOADING)
    FileChooserRequestGetSelectedFilesMethodInfo,
#endif
    fileChooserRequestGetSelectedFiles      ,


-- ** selectFiles #method:selectFiles#

#if defined(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 defined(ENABLE_OVERLOADING)
    FileChooserRequestFilterPropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    fileChooserRequestFilter                ,
#endif
    getFileChooserRequestFilter             ,


-- ** mimeTypes #attr:mimeTypes#
-- | A 'P.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 defined(ENABLE_OVERLOADING)
    FileChooserRequestMimeTypesPropertyInfo ,
#endif
#if defined(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 defined(ENABLE_OVERLOADING)
    FileChooserRequestSelectMultiplePropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    fileChooserRequestSelectMultiple        ,
#endif
    getFileChooserRequestSelectMultiple     ,


-- ** selectedFiles #attr:selectedFiles#
-- | A 'P.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 defined(ENABLE_OVERLOADING)
    FileChooserRequestSelectedFilesPropertyInfo,
#endif
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Objects.FileFilter as Gtk.FileFilter

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

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

foreign import ccall "webkit_file_chooser_request_get_type"
    c_webkit_file_chooser_request_get_type :: IO B.Types.GType

instance B.Types.TypedObject FileChooserRequest where
    glibType :: IO GType
glibType = IO GType
c_webkit_file_chooser_request_get_type

instance B.Types.GObject FileChooserRequest

-- | Type class for types which can be safely cast to `FileChooserRequest`, for instance with `toFileChooserRequest`.
class (SP.GObject o, O.IsDescendantOf FileChooserRequest o) => IsFileChooserRequest o
instance (SP.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 :: (MIO.MonadIO m, IsFileChooserRequest o) => o -> m FileChooserRequest
toFileChooserRequest :: forall (m :: * -> *) o.
(MonadIO m, IsFileChooserRequest o) =>
o -> m FileChooserRequest
toFileChooserRequest = IO FileChooserRequest -> m FileChooserRequest
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO FileChooserRequest -> m FileChooserRequest)
-> (o -> IO FileChooserRequest) -> o -> m FileChooserRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr FileChooserRequest -> FileChooserRequest)
-> o -> IO FileChooserRequest
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr FileChooserRequest -> FileChooserRequest
FileChooserRequest

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

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveFileChooserRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFileChooserRequestMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFileChooserRequestMethod t FileChooserRequest, O.OverloadedMethod info FileChooserRequest p) => OL.IsLabel t (FileChooserRequest -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveFileChooserRequestMethod t FileChooserRequest, O.OverloadedMethod info FileChooserRequest p, R.HasField t FileChooserRequest p) => R.HasField t FileChooserRequest p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveFileChooserRequestMethod t FileChooserRequest, O.OverloadedMethodInfo info FileChooserRequest) => OL.IsLabel t (O.MethodProxy info FileChooserRequest) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 :: forall (m :: * -> *) o.
(MonadIO m, IsFileChooserRequest o) =>
o -> m (Maybe FileFilter)
getFileChooserRequestFilter o
obj = IO (Maybe FileFilter) -> m (Maybe FileFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe FileFilter) -> m (Maybe FileFilter))
-> IO (Maybe FileFilter) -> m (Maybe FileFilter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr FileFilter -> FileFilter)
-> IO (Maybe FileFilter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"filter" ManagedPtr FileFilter -> FileFilter
Gtk.FileFilter.FileFilter

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestFilterPropertyInfo
instance AttrInfo FileChooserRequestFilterPropertyInfo where
    type AttrAllowedOps FileChooserRequestFilterPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FileChooserRequestFilterPropertyInfo = IsFileChooserRequest
    type AttrSetTypeConstraint FileChooserRequestFilterPropertyInfo = (~) ()
    type AttrTransferTypeConstraint FileChooserRequestFilterPropertyInfo = (~) ()
    type AttrTransferType FileChooserRequestFilterPropertyInfo = ()
    type AttrGetType FileChooserRequestFilterPropertyInfo = (Maybe Gtk.FileFilter.FileFilter)
    type AttrLabel FileChooserRequestFilterPropertyInfo = "filter"
    type AttrOrigin FileChooserRequestFilterPropertyInfo = FileChooserRequest
    attrGet = getFileChooserRequestFilter
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.filter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#g:attr:filter"
        })
#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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fileChooserRequest #mimeTypes
-- @
getFileChooserRequestMimeTypes :: (MonadIO m, IsFileChooserRequest o) => o -> m [T.Text]
getFileChooserRequestMimeTypes :: forall (m :: * -> *) o.
(MonadIO m, IsFileChooserRequest o) =>
o -> m [Text]
getFileChooserRequestMimeTypes o
obj = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe [Text]) -> IO [Text]
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getFileChooserRequestMimeTypes" (IO (Maybe [Text]) -> IO [Text]) -> IO (Maybe [Text]) -> IO [Text]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"mime-types"

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestMimeTypesPropertyInfo
instance AttrInfo FileChooserRequestMimeTypesPropertyInfo where
    type AttrAllowedOps FileChooserRequestMimeTypesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FileChooserRequestMimeTypesPropertyInfo = IsFileChooserRequest
    type AttrSetTypeConstraint FileChooserRequestMimeTypesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint FileChooserRequestMimeTypesPropertyInfo = (~) ()
    type AttrTransferType FileChooserRequestMimeTypesPropertyInfo = ()
    type AttrGetType FileChooserRequestMimeTypesPropertyInfo = [T.Text]
    type AttrLabel FileChooserRequestMimeTypesPropertyInfo = "mime-types"
    type AttrOrigin FileChooserRequestMimeTypesPropertyInfo = FileChooserRequest
    attrGet = getFileChooserRequestMimeTypes
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.mimeTypes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#g:attr:mimeTypes"
        })
#endif

-- VVV Prop "select-multiple"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestSelectMultiplePropertyInfo
instance AttrInfo FileChooserRequestSelectMultiplePropertyInfo where
    type AttrAllowedOps FileChooserRequestSelectMultiplePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint FileChooserRequestSelectMultiplePropertyInfo = IsFileChooserRequest
    type AttrSetTypeConstraint FileChooserRequestSelectMultiplePropertyInfo = (~) ()
    type AttrTransferTypeConstraint FileChooserRequestSelectMultiplePropertyInfo = (~) ()
    type AttrTransferType FileChooserRequestSelectMultiplePropertyInfo = ()
    type AttrGetType FileChooserRequestSelectMultiplePropertyInfo = Bool
    type AttrLabel FileChooserRequestSelectMultiplePropertyInfo = "select-multiple"
    type AttrOrigin FileChooserRequestSelectMultiplePropertyInfo = FileChooserRequest
    attrGet = getFileChooserRequestSelectMultiple
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.selectMultiple"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#g:attr:selectMultiple"
        })
#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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fileChooserRequest #selectedFiles
-- @
getFileChooserRequestSelectedFiles :: (MonadIO m, IsFileChooserRequest o) => o -> m (Maybe [T.Text])
getFileChooserRequestSelectedFiles :: forall (m :: * -> *) o.
(MonadIO m, IsFileChooserRequest o) =>
o -> m (Maybe [Text])
getFileChooserRequestSelectedFiles o
obj = IO (Maybe [Text]) -> m (Maybe [Text])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"selected-files"

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestSelectedFilesPropertyInfo
instance AttrInfo FileChooserRequestSelectedFilesPropertyInfo where
    type AttrAllowedOps FileChooserRequestSelectedFilesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FileChooserRequestSelectedFilesPropertyInfo = IsFileChooserRequest
    type AttrSetTypeConstraint FileChooserRequestSelectedFilesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint FileChooserRequestSelectedFilesPropertyInfo = (~) ()
    type AttrTransferType FileChooserRequestSelectedFilesPropertyInfo = ()
    type AttrGetType FileChooserRequestSelectedFilesPropertyInfo = (Maybe [T.Text])
    type AttrLabel FileChooserRequestSelectedFilesPropertyInfo = "selected-files"
    type AttrOrigin FileChooserRequestSelectedFilesPropertyInfo = FileChooserRequest
    attrGet = getFileChooserRequestSelectedFiles
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.selectedFiles"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#g:attr:selectedFiles"
        })
#endif

#if defined(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 defined(ENABLE_OVERLOADING)
fileChooserRequestFilter :: AttrLabelProxy "filter"
fileChooserRequestFilter = AttrLabelProxy

fileChooserRequestMimeTypes :: AttrLabelProxy "mimeTypes"
fileChooserRequestMimeTypes = AttrLabelProxy

fileChooserRequestSelectMultiple :: AttrLabelProxy "selectMultiple"
fileChooserRequestSelectMultiple = AttrLabelProxy

fileChooserRequestSelectedFiles :: AttrLabelProxy "selectedFiles"
fileChooserRequestSelectedFiles = AttrLabelProxy

#endif

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

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestCancelMethodInfo
instance (signature ~ (m ()), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestCancelMethodInfo a signature where
    overloadedMethod = fileChooserRequestCancel

instance O.OverloadedMethodInfo FileChooserRequestCancelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestCancel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v: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.
-- 
-- 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 t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest'
    -> m [T.Text]
    -- ^ __Returns:__ a
    -- 'P.Nothing'-terminated array of strings if a list of accepted MIME types
    -- is defined or 'P.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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileChooserRequest a) =>
a -> m [Text]
fileChooserRequestGetMimeTypes a
request = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileChooserRequest
request' <- a -> IO (Ptr FileChooserRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr CString
result <- Ptr FileChooserRequest -> IO (Ptr CString)
webkit_file_chooser_request_get_mime_types Ptr FileChooserRequest
request'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fileChooserRequestGetMimeTypes" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestGetMimeTypesMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestGetMimeTypesMethodInfo a signature where
    overloadedMethod = fileChooserRequestGetMimeTypes

instance O.OverloadedMethodInfo FileChooserRequestGetMimeTypesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetMimeTypes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v: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.
-- 
-- Get the filter currently associated with the request, ready to be
-- used by t'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 t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest'
    -> m (Maybe Gtk.FileFilter.FileFilter)
    -- ^ __Returns:__ a t'GI.Gtk.Objects.FileFilter.FileFilter' if a list of accepted
    -- MIME types is defined or 'P.Nothing' otherwise. The returned object is
    -- owned by WebKit should not be modified or freed.
fileChooserRequestGetMimeTypesFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileChooserRequest a) =>
a -> m (Maybe FileFilter)
fileChooserRequestGetMimeTypesFilter a
request = IO (Maybe FileFilter) -> m (Maybe FileFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FileFilter) -> m (Maybe FileFilter))
-> IO (Maybe FileFilter) -> m (Maybe FileFilter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileChooserRequest
request' <- a -> IO (Ptr FileChooserRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr FileFilter
result <- Ptr FileChooserRequest -> IO (Ptr FileFilter)
webkit_file_chooser_request_get_mime_types_filter Ptr FileChooserRequest
request'
    Maybe FileFilter
maybeResult <- Ptr FileFilter
-> (Ptr FileFilter -> IO FileFilter) -> IO (Maybe FileFilter)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr FileFilter
result ((Ptr FileFilter -> IO FileFilter) -> IO (Maybe FileFilter))
-> (Ptr FileFilter -> IO FileFilter) -> IO (Maybe FileFilter)
forall a b. (a -> b) -> a -> b
$ \Ptr FileFilter
result' -> do
        FileFilter
result'' <- ((ManagedPtr FileFilter -> FileFilter)
-> Ptr FileFilter -> IO FileFilter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FileFilter -> FileFilter
Gtk.FileFilter.FileFilter) Ptr FileFilter
result'
        FileFilter -> IO FileFilter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileFilter
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Maybe FileFilter -> IO (Maybe FileFilter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileFilter
maybeResult

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestGetMimeTypesFilterMethodInfo
instance (signature ~ (m (Maybe Gtk.FileFilter.FileFilter)), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestGetMimeTypesFilterMethodInfo a signature where
    overloadedMethod = fileChooserRequestGetMimeTypesFilter

instance O.OverloadedMethodInfo FileChooserRequestGetMimeTypesFilterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetMimeTypesFilter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v: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

-- | Whether the file chooser should allow selecting multiple files.
-- 
-- Determine whether the file chooser associated to this
-- t'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 t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the file chooser should allow selecting multiple files or 'P.False' otherwise.
fileChooserRequestGetSelectMultiple :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileChooserRequest a) =>
a -> m Bool
fileChooserRequestGetSelectMultiple a
request = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileChooserRequest
request' <- a -> IO (Ptr FileChooserRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    CInt
result <- Ptr FileChooserRequest -> IO CInt
webkit_file_chooser_request_get_select_multiple Ptr FileChooserRequest
request'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestGetSelectMultipleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestGetSelectMultipleMethodInfo a signature where
    overloadedMethod = fileChooserRequestGetSelectMultiple

instance O.OverloadedMethodInfo FileChooserRequestGetSelectMultipleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetSelectMultiple",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v: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 associated to the request.
-- 
-- 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 t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest'
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ a
    -- 'P.Nothing'-terminated array of strings if there are selected files
    -- associated with the request or 'P.Nothing' otherwise. This array and its
    -- contents are owned by WebKit and should not be modified or
    -- freed.
fileChooserRequestGetSelectedFiles :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileChooserRequest a) =>
a -> m (Maybe [Text])
fileChooserRequestGetSelectedFiles a
request = IO (Maybe [Text]) -> m (Maybe [Text])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileChooserRequest
request' <- a -> IO (Ptr FileChooserRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr CString
result <- Ptr FileChooserRequest -> IO (Ptr CString)
webkit_file_chooser_request_get_selected_files Ptr FileChooserRequest
request'
    Maybe [Text]
maybeResult <- Ptr CString -> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CString
result ((Ptr CString -> IO [Text]) -> IO (Maybe [Text]))
-> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ \Ptr CString
result' -> do
        [Text]
result'' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result'
        [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    Maybe [Text] -> IO (Maybe [Text])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestGetSelectedFilesMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestGetSelectedFilesMethodInfo a signature where
    overloadedMethod = fileChooserRequestGetSelectedFiles

instance O.OverloadedMethodInfo FileChooserRequestGetSelectedFilesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestGetSelectedFiles",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v: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 t'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest'
    -> [T.Text]
    -- ^ /@files@/: a
    -- 'P.Nothing'-terminated array of strings, containing paths to local files.
    -> m ()
fileChooserRequestSelectFiles :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileChooserRequest a) =>
a -> [Text] -> m ()
fileChooserRequestSelectFiles a
request [Text]
files = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileChooserRequest
request' <- a -> IO (Ptr FileChooserRequest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
request
    Ptr CString
files' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
files
    Ptr FileChooserRequest -> Ptr CString -> IO ()
webkit_file_chooser_request_select_files Ptr FileChooserRequest
request' Ptr CString
files'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
request
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
files'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
files'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FileChooserRequestSelectFilesMethodInfo
instance (signature ~ ([T.Text] -> m ()), MonadIO m, IsFileChooserRequest a) => O.OverloadedMethod FileChooserRequestSelectFilesMethodInfo a signature where
    overloadedMethod = fileChooserRequestSelectFiles

instance O.OverloadedMethodInfo FileChooserRequestSelectFilesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2.Objects.FileChooserRequest.fileChooserRequestSelectFiles",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.29/docs/GI-WebKit2-Objects-FileChooserRequest.html#v:fileChooserRequestSelectFiles"
        })


#endif