{-# 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.OptionMenu
    ( 

-- * Exported types
    OptionMenu(..)                          ,
    IsOptionMenu                            ,
    toOptionMenu                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activateItem]("GI.WebKit2.Objects.OptionMenu#g:method:activateItem"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [close]("GI.WebKit2.Objects.OptionMenu#g:method:close"), [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"), [selectItem]("GI.WebKit2.Objects.OptionMenu#g:method:selectItem"), [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"), [getItem]("GI.WebKit2.Objects.OptionMenu#g:method:getItem"), [getNItems]("GI.WebKit2.Objects.OptionMenu#g:method:getNItems"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== 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)
    ResolveOptionMenuMethod                 ,
#endif

-- ** activateItem #method:activateItem#

#if defined(ENABLE_OVERLOADING)
    OptionMenuActivateItemMethodInfo        ,
#endif
    optionMenuActivateItem                  ,


-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    OptionMenuCloseMethodInfo               ,
#endif
    optionMenuClose                         ,


-- ** getItem #method:getItem#

#if defined(ENABLE_OVERLOADING)
    OptionMenuGetItemMethodInfo             ,
#endif
    optionMenuGetItem                       ,


-- ** getNItems #method:getNItems#

#if defined(ENABLE_OVERLOADING)
    OptionMenuGetNItemsMethodInfo           ,
#endif
    optionMenuGetNItems                     ,


-- ** selectItem #method:selectItem#

#if defined(ENABLE_OVERLOADING)
    OptionMenuSelectItemMethodInfo          ,
#endif
    optionMenuSelectItem                    ,




 -- * Signals


-- ** close #signal:close#

    C_OptionMenuCloseCallback               ,
    OptionMenuCloseCallback                 ,
#if defined(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.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.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.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 {-# SOURCE #-} qualified GI.WebKit2.Structs.OptionMenuItem as WebKit2.OptionMenuItem

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

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

foreign import ccall "webkit_option_menu_get_type"
    c_webkit_option_menu_get_type :: IO B.Types.GType

instance B.Types.TypedObject OptionMenu where
    glibType :: IO GType
glibType = IO GType
c_webkit_option_menu_get_type

instance B.Types.GObject OptionMenu

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

-- | Convert 'OptionMenu' 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 OptionMenu) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_option_menu_get_type
    gvalueSet_ :: Ptr GValue -> Maybe OptionMenu -> IO ()
gvalueSet_ Ptr GValue
gv Maybe OptionMenu
P.Nothing = Ptr GValue -> Ptr OptionMenu -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr OptionMenu
forall a. Ptr a
FP.nullPtr :: FP.Ptr OptionMenu)
    gvalueSet_ Ptr GValue
gv (P.Just OptionMenu
obj) = OptionMenu -> (Ptr OptionMenu -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr OptionMenu
obj (Ptr GValue -> Ptr OptionMenu -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe OptionMenu)
gvalueGet_ Ptr GValue
gv = do
        Ptr OptionMenu
ptr <- Ptr GValue -> IO (Ptr OptionMenu)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr OptionMenu)
        if Ptr OptionMenu
ptr Ptr OptionMenu -> Ptr OptionMenu -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr OptionMenu
forall a. Ptr a
FP.nullPtr
        then OptionMenu -> Maybe OptionMenu
forall a. a -> Maybe a
P.Just (OptionMenu -> Maybe OptionMenu)
-> IO OptionMenu -> IO (Maybe OptionMenu)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr OptionMenu -> OptionMenu)
-> Ptr OptionMenu -> IO OptionMenu
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr OptionMenu -> OptionMenu
OptionMenu Ptr OptionMenu
ptr
        else Maybe OptionMenu -> IO (Maybe OptionMenu)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OptionMenu
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveOptionMenuMethod t OptionMenu, O.OverloadedMethod info OptionMenu p) => OL.IsLabel t (OptionMenu -> 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 ~ ResolveOptionMenuMethod t OptionMenu, O.OverloadedMethod info OptionMenu p, R.HasField t OptionMenu p) => R.HasField t OptionMenu p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveOptionMenuMethod t OptionMenu, O.OverloadedMethodInfo info OptionMenu) => OL.IsLabel t (O.MethodProxy info OptionMenu) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal OptionMenu::close
-- | Emitted when closing a t'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 :: Maybe (IO ())
noOptionMenuCloseCallback = Maybe (IO ())
forall a. Maybe a
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 :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_OptionMenuCloseCallback)
genClosure_OptionMenuClose IO ()
cb = IO (GClosure C_OptionMenuCloseCallback)
-> m (GClosure C_OptionMenuCloseCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_OptionMenuCloseCallback)
 -> m (GClosure C_OptionMenuCloseCallback))
-> IO (GClosure C_OptionMenuCloseCallback)
-> m (GClosure C_OptionMenuCloseCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_OptionMenuCloseCallback
cb' = IO () -> C_OptionMenuCloseCallback
wrap_OptionMenuCloseCallback IO ()
cb
    C_OptionMenuCloseCallback -> IO (FunPtr C_OptionMenuCloseCallback)
mk_OptionMenuCloseCallback C_OptionMenuCloseCallback
cb' IO (FunPtr C_OptionMenuCloseCallback)
-> (FunPtr C_OptionMenuCloseCallback
    -> IO (GClosure C_OptionMenuCloseCallback))
-> IO (GClosure C_OptionMenuCloseCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_OptionMenuCloseCallback
-> IO (GClosure C_OptionMenuCloseCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `OptionMenuCloseCallback` into a `C_OptionMenuCloseCallback`.
wrap_OptionMenuCloseCallback ::
    OptionMenuCloseCallback ->
    C_OptionMenuCloseCallback
wrap_OptionMenuCloseCallback :: IO () -> C_OptionMenuCloseCallback
wrap_OptionMenuCloseCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [close](#signal:close) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' optionMenu #close callback
-- @
-- 
-- 
onOptionMenuClose :: (IsOptionMenu a, MonadIO m) => a -> OptionMenuCloseCallback -> m SignalHandlerId
onOptionMenuClose :: forall a (m :: * -> *).
(IsOptionMenu a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onOptionMenuClose a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_OptionMenuCloseCallback
cb' = IO () -> C_OptionMenuCloseCallback
wrap_OptionMenuCloseCallback IO ()
cb
    FunPtr C_OptionMenuCloseCallback
cb'' <- C_OptionMenuCloseCallback -> IO (FunPtr C_OptionMenuCloseCallback)
mk_OptionMenuCloseCallback C_OptionMenuCloseCallback
cb'
    a
-> Text
-> FunPtr C_OptionMenuCloseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close" FunPtr C_OptionMenuCloseCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [close](#signal:close) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' optionMenu #close callback
-- @
-- 
-- 
afterOptionMenuClose :: (IsOptionMenu a, MonadIO m) => a -> OptionMenuCloseCallback -> m SignalHandlerId
afterOptionMenuClose :: forall a (m :: * -> *).
(IsOptionMenu a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterOptionMenuClose a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_OptionMenuCloseCallback
cb' = IO () -> C_OptionMenuCloseCallback
wrap_OptionMenuCloseCallback IO ()
cb
    FunPtr C_OptionMenuCloseCallback
cb'' <- C_OptionMenuCloseCallback -> IO (FunPtr C_OptionMenuCloseCallback)
mk_OptionMenuCloseCallback C_OptionMenuCloseCallback
cb'
    a
-> Text
-> FunPtr C_OptionMenuCloseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close" FunPtr C_OptionMenuCloseCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data OptionMenuCloseSignalInfo
instance SignalInfo OptionMenuCloseSignalInfo where
    type HaskellCallbackType OptionMenuCloseSignalInfo = OptionMenuCloseCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_OptionMenuCloseCallback cb
        cb'' <- mk_OptionMenuCloseCallback cb'
        connectSignalFunPtr obj "close" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
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 t'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 t'GI.WebKit2.Objects.OptionMenu.OptionMenu'
    -> Word32
    -- ^ /@index@/: the index of the item
    -> m ()
optionMenuActivateItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOptionMenu a) =>
a -> Word32 -> m ()
optionMenuActivateItem a
menu Word32
index = 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 OptionMenu
menu' <- a -> IO (Ptr OptionMenu)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menu
    Ptr OptionMenu -> Word32 -> IO ()
webkit_option_menu_activate_item Ptr OptionMenu
menu' Word32
index
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menu
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionMenuActivateItemMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsOptionMenu a) => O.OverloadedMethod OptionMenuActivateItemMethodInfo a signature where
    overloadedMethod = optionMenuActivateItem

instance O.OverloadedMethodInfo OptionMenuActivateItemMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.OptionMenu.optionMenuActivateItem",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-OptionMenu.html#v: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 t'GI.WebKit2.Objects.OptionMenu.OptionMenu'. This emits WebKitOptionMenu[close](#g:signal: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 t'GI.WebKit2.Objects.OptionMenu.OptionMenu'
    -> m ()
optionMenuClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOptionMenu a) =>
a -> m ()
optionMenuClose a
menu = 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 OptionMenu
menu' <- a -> IO (Ptr OptionMenu)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menu
    Ptr OptionMenu -> IO ()
webkit_option_menu_close Ptr OptionMenu
menu'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menu
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionMenuCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsOptionMenu a) => O.OverloadedMethod OptionMenuCloseMethodInfo a signature where
    overloadedMethod = optionMenuClose

instance O.OverloadedMethodInfo OptionMenuCloseMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.OptionMenu.optionMenuClose",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-OptionMenu.html#v: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 t'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/.
-- 
-- /Since: 2.18/
optionMenuGetItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    -- ^ /@menu@/: a t'GI.WebKit2.Objects.OptionMenu.OptionMenu'
    -> Word32
    -- ^ /@index@/: the index of the item
    -> m (Maybe WebKit2.OptionMenuItem.OptionMenuItem)
    -- ^ __Returns:__ a t'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' of /@menu@/.
optionMenuGetItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOptionMenu a) =>
a -> Word32 -> m (Maybe OptionMenuItem)
optionMenuGetItem a
menu Word32
index = IO (Maybe OptionMenuItem) -> m (Maybe OptionMenuItem)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OptionMenuItem) -> m (Maybe OptionMenuItem))
-> IO (Maybe OptionMenuItem) -> m (Maybe OptionMenuItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr OptionMenu
menu' <- a -> IO (Ptr OptionMenu)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menu
    Ptr OptionMenuItem
result <- Ptr OptionMenu -> Word32 -> IO (Ptr OptionMenuItem)
webkit_option_menu_get_item Ptr OptionMenu
menu' Word32
index
    Maybe OptionMenuItem
maybeResult <- Ptr OptionMenuItem
-> (Ptr OptionMenuItem -> IO OptionMenuItem)
-> IO (Maybe OptionMenuItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OptionMenuItem
result ((Ptr OptionMenuItem -> IO OptionMenuItem)
 -> IO (Maybe OptionMenuItem))
-> (Ptr OptionMenuItem -> IO OptionMenuItem)
-> IO (Maybe OptionMenuItem)
forall a b. (a -> b) -> a -> b
$ \Ptr OptionMenuItem
result' -> do
        OptionMenuItem
result'' <- ((ManagedPtr OptionMenuItem -> OptionMenuItem)
-> Ptr OptionMenuItem -> IO OptionMenuItem
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr OptionMenuItem -> OptionMenuItem
WebKit2.OptionMenuItem.OptionMenuItem) Ptr OptionMenuItem
result'
        OptionMenuItem -> IO OptionMenuItem
forall (m :: * -> *) a. Monad m => a -> m a
return OptionMenuItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menu
    Maybe OptionMenuItem -> IO (Maybe OptionMenuItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OptionMenuItem
maybeResult

#if defined(ENABLE_OVERLOADING)
data OptionMenuGetItemMethodInfo
instance (signature ~ (Word32 -> m (Maybe WebKit2.OptionMenuItem.OptionMenuItem)), MonadIO m, IsOptionMenu a) => O.OverloadedMethod OptionMenuGetItemMethodInfo a signature where
    overloadedMethod = optionMenuGetItem

instance O.OverloadedMethodInfo OptionMenuGetItemMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.OptionMenu.optionMenuGetItem",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-OptionMenu.html#v: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 t'GI.WebKit2.Objects.OptionMenu.OptionMenu'
    -> m Word32
    -- ^ __Returns:__ the number of t'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem's in /@menu@/
optionMenuGetNItems :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOptionMenu a) =>
a -> m Word32
optionMenuGetNItems a
menu = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr OptionMenu
menu' <- a -> IO (Ptr OptionMenu)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menu
    Word32
result <- Ptr OptionMenu -> IO Word32
webkit_option_menu_get_n_items Ptr OptionMenu
menu'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menu
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data OptionMenuGetNItemsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsOptionMenu a) => O.OverloadedMethod OptionMenuGetNItemsMethodInfo a signature where
    overloadedMethod = optionMenuGetNItems

instance O.OverloadedMethodInfo OptionMenuGetNItemsMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.OptionMenu.optionMenuGetNItems",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-OptionMenu.html#v: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 t'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 t'GI.WebKit2.Objects.OptionMenu.OptionMenu'
    -> Word32
    -- ^ /@index@/: the index of the item
    -> m ()
optionMenuSelectItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOptionMenu a) =>
a -> Word32 -> m ()
optionMenuSelectItem a
menu Word32
index = 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 OptionMenu
menu' <- a -> IO (Ptr OptionMenu)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
menu
    Ptr OptionMenu -> Word32 -> IO ()
webkit_option_menu_select_item Ptr OptionMenu
menu' Word32
index
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
menu
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OptionMenuSelectItemMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsOptionMenu a) => O.OverloadedMethod OptionMenuSelectItemMethodInfo a signature where
    overloadedMethod = optionMenuSelectItem

instance O.OverloadedMethodInfo OptionMenuSelectItemMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2.Objects.OptionMenu.optionMenuSelectItem",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2-4.0.27/docs/GI-WebKit2-Objects-OptionMenu.html#v:optionMenuSelectItem"
        }


#endif