OptionMenu.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.WebKit2.Objects.OptionMenu
    ( 

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


 -- * Methods
-- ** activateItem #method:activateItem#

#if ENABLE_OVERLOADING
    OptionMenuActivateItemMethodInfo        ,
#endif
    optionMenuActivateItem                  ,


-- ** close #method:close#

#if ENABLE_OVERLOADING
    OptionMenuCloseMethodInfo               ,
#endif
    optionMenuClose                         ,


-- ** getItem #method:getItem#

#if ENABLE_OVERLOADING
    OptionMenuGetItemMethodInfo             ,
#endif
    optionMenuGetItem                       ,


-- ** getNItems #method:getNItems#

#if ENABLE_OVERLOADING
    OptionMenuGetNItemsMethodInfo           ,
#endif
    optionMenuGetNItems                     ,


-- ** selectItem #method:selectItem#

#if ENABLE_OVERLOADING
    OptionMenuSelectItemMethodInfo          ,
#endif
    optionMenuSelectItem                    ,




 -- * Signals
-- ** close #signal:close#

    C_OptionMenuCloseCallback               ,
    OptionMenuCloseCallback                 ,
#if ENABLE_OVERLOADING
    OptionMenuCloseSignalInfo               ,
#endif
    afterOptionMenuClose                    ,
    genClosure_OptionMenuClose              ,
    mk_OptionMenuCloseCallback              ,
    noOptionMenuCloseCallback               ,
    onOptionMenuClose                       ,
    wrap_OptionMenuCloseCallback            ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2.Structs.OptionMenuItem as WebKit2.OptionMenuItem

-- | Memory-managed wrapper type.
newtype OptionMenu = OptionMenu (ManagedPtr OptionMenu)
foreign import ccall "webkit_option_menu_get_type"
    c_webkit_option_menu_get_type :: IO GType

instance GObject OptionMenu where
    gobjectType = c_webkit_option_menu_get_type
    

-- | Type class for types which can be safely cast to `OptionMenu`, for instance with `toOptionMenu`.
class (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o
instance (GObject o, O.IsDescendantOf OptionMenu o) => IsOptionMenu o

instance O.HasParentTypes OptionMenu
type instance O.ParentTypes OptionMenu = '[GObject.Object.Object]

-- | Cast to `OptionMenu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toOptionMenu :: (MonadIO m, IsOptionMenu o) => o -> m OptionMenu
toOptionMenu = liftIO . unsafeCastTo OptionMenu

-- | A convenience alias for `Nothing` :: `Maybe` `OptionMenu`.
noOptionMenu :: Maybe OptionMenu
noOptionMenu = Nothing

#if ENABLE_OVERLOADING
type family ResolveOptionMenuMethod (t :: Symbol) (o :: *) :: * where
    ResolveOptionMenuMethod "activateItem" o = OptionMenuActivateItemMethodInfo
    ResolveOptionMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveOptionMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveOptionMenuMethod "close" o = OptionMenuCloseMethodInfo
    ResolveOptionMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveOptionMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveOptionMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveOptionMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveOptionMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveOptionMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveOptionMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveOptionMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveOptionMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveOptionMenuMethod "selectItem" o = OptionMenuSelectItemMethodInfo
    ResolveOptionMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveOptionMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveOptionMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveOptionMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveOptionMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveOptionMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveOptionMenuMethod "getItem" o = OptionMenuGetItemMethodInfo
    ResolveOptionMenuMethod "getNItems" o = OptionMenuGetNItemsMethodInfo
    ResolveOptionMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveOptionMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveOptionMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveOptionMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveOptionMenuMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal OptionMenu::close
{- |
Emitted when closing a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' is requested. This can happen
when the user explicitly calls 'GI.WebKit2.Objects.OptionMenu.optionMenuClose' or when the
element is detached from the current page.

/Since: 2.18/
-}
type OptionMenuCloseCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionMenuCloseCallback`@.
noOptionMenuCloseCallback :: Maybe OptionMenuCloseCallback
noOptionMenuCloseCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_OptionMenuCloseCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_OptionMenuCloseCallback`.
foreign import ccall "wrapper"
    mk_OptionMenuCloseCallback :: C_OptionMenuCloseCallback -> IO (FunPtr C_OptionMenuCloseCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_OptionMenuClose :: MonadIO m => OptionMenuCloseCallback -> m (GClosure C_OptionMenuCloseCallback)
genClosure_OptionMenuClose cb = liftIO $ do
    let cb' = wrap_OptionMenuCloseCallback cb
    mk_OptionMenuCloseCallback cb' >>= B.GClosure.newGClosure


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


{- |
Connect a signal handler for the “@close@” signal, to be run before the default handler.
When <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 obj cb = liftIO $ do
    let cb' = wrap_OptionMenuCloseCallback cb
    cb'' <- mk_OptionMenuCloseCallback cb'
    connectSignalFunPtr obj "close" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@close@” signal, to be run after the default handler.
When <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 obj cb = liftIO $ do
    let cb' = wrap_OptionMenuCloseCallback cb
    cb'' <- mk_OptionMenuCloseCallback cb'
    connectSignalFunPtr obj "close" cb'' SignalConnectAfter


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

#if ENABLE_OVERLOADING
#endif

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

type instance O.SignalList OptionMenu = OptionMenuSignalList
type OptionMenuSignalList = ('[ '("close", OptionMenuCloseSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method OptionMenu::activate_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_option_menu_activate_item" webkit_option_menu_activate_item :: 
    Ptr OptionMenu ->                       -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"})
    Word32 ->                               -- index : TBasicType TUInt
    IO ()

{- |
Activates the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/. Activating an item changes the value
of the element making the item the active one. You are expected to close the menu with
'GI.WebKit2.Objects.OptionMenu.optionMenuClose' after activating an item, calling this function again will have no
effect.

/Since: 2.18/
-}
optionMenuActivateItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> Word32
    {- ^ /@index@/: the index of the item -}
    -> m ()
optionMenuActivateItem menu index = liftIO $ do
    menu' <- unsafeManagedPtrCastPtr menu
    webkit_option_menu_activate_item menu' index
    touchManagedPtr menu
    return ()

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

#endif

-- method OptionMenu::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_option_menu_close" webkit_option_menu_close :: 
    Ptr OptionMenu ->                       -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"})
    IO ()

{- |
Request to close a 'GI.WebKit2.Objects.OptionMenu.OptionMenu'. This emits WebKitOptionMenu::close signal.
This function should always be called to notify WebKit that the associated
menu has been closed. If the menu is closed and neither 'GI.WebKit2.Objects.OptionMenu.optionMenuSelectItem'
nor 'GI.WebKit2.Objects.OptionMenu.optionMenuActivateItem' have been called, the element value remains
unchanged.

/Since: 2.18/
-}
optionMenuClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> m ()
optionMenuClose menu = liftIO $ do
    menu' <- unsafeManagedPtrCastPtr menu
    webkit_option_menu_close menu'
    touchManagedPtr menu
    return ()

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

#endif

-- method OptionMenu::get_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "OptionMenuItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_option_menu_get_item" webkit_option_menu_get_item :: 
    Ptr OptionMenu ->                       -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"})
    Word32 ->                               -- index : TBasicType TUInt
    IO (Ptr WebKit2.OptionMenuItem.OptionMenuItem)

{- |
Returns the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/.

/Since: 2.18/
-}
optionMenuGetItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> Word32
    {- ^ /@index@/: the index of the item -}
    -> m (Maybe WebKit2.OptionMenuItem.OptionMenuItem)
    {- ^ __Returns:__ a 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' of /@menu@/. -}
optionMenuGetItem menu index = liftIO $ do
    menu' <- unsafeManagedPtrCastPtr menu
    result <- webkit_option_menu_get_item menu' index
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed WebKit2.OptionMenuItem.OptionMenuItem) result'
        return result''
    touchManagedPtr menu
    return maybeResult

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

#endif

-- method OptionMenu::get_n_items
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_option_menu_get_n_items" webkit_option_menu_get_n_items :: 
    Ptr OptionMenu ->                       -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"})
    IO Word32

{- |
Gets the length of the /@menu@/.

/Since: 2.18/
-}
optionMenuGetNItems ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> m Word32
    {- ^ __Returns:__ the number of 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem'\<!-- -->s in /@menu@/ -}
optionMenuGetNItems menu = liftIO $ do
    menu' <- unsafeManagedPtrCastPtr menu
    result <- webkit_option_menu_get_n_items menu'
    touchManagedPtr menu
    return result

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

#endif

-- method OptionMenu::select_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "menu", argType = TInterface (Name {namespace = "WebKit2", name = "OptionMenu"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitOptionMenu", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_option_menu_select_item" webkit_option_menu_select_item :: 
    Ptr OptionMenu ->                       -- menu : TInterface (Name {namespace = "WebKit2", name = "OptionMenu"})
    Word32 ->                               -- index : TBasicType TUInt
    IO ()

{- |
Selects the 'GI.WebKit2.Structs.OptionMenuItem.OptionMenuItem' at /@index@/ in /@menu@/. Selecting an item changes the
text shown by the combo button, but it doesn\'t change the value of the element. You need to
explicitly activate the item with 'GI.WebKit2.Objects.OptionMenu.optionMenuSelectItem' or close the menu with
'GI.WebKit2.Objects.OptionMenu.optionMenuClose' in which case the currently selected item will be activated.

/Since: 2.18/
-}
optionMenuSelectItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsOptionMenu a) =>
    a
    {- ^ /@menu@/: a 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> Word32
    {- ^ /@index@/: the index of the item -}
    -> m ()
optionMenuSelectItem menu index = liftIO $ do
    menu' <- unsafeManagedPtrCastPtr menu
    webkit_option_menu_select_item menu' index
    touchManagedPtr menu
    return ()

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

#endif