{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.WebKit2WebExtension.Structs.ContextMenu_
    ( 

-- * Exported types
    ContextMenu_(..)                        ,
    newZeroContextMenu_                     ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveContextMenu_Method               ,
#endif



 -- * Properties


-- ** parent #attr:parent#
-- | /No description available in the introspection data./

    clearContextMenu_Parent                 ,
#if defined(ENABLE_OVERLOADING)
    contextMenu__parent                     ,
#endif
    getContextMenu_Parent                   ,
    setContextMenu_Parent                   ,




    ) 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

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

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

instance BoxedPtr ContextMenu_ where
    boxedPtrCopy :: ContextMenu_ -> IO ContextMenu_
boxedPtrCopy = \ContextMenu_
p -> ContextMenu_
-> (Ptr ContextMenu_ -> IO ContextMenu_) -> IO ContextMenu_
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContextMenu_
p (Int -> Ptr ContextMenu_ -> IO (Ptr ContextMenu_)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
32 (Ptr ContextMenu_ -> IO (Ptr ContextMenu_))
-> (Ptr ContextMenu_ -> IO ContextMenu_)
-> Ptr ContextMenu_
-> IO ContextMenu_
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ContextMenu_ -> ContextMenu_)
-> Ptr ContextMenu_ -> IO ContextMenu_
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ContextMenu_ -> ContextMenu_
ContextMenu_)
    boxedPtrFree :: ContextMenu_ -> IO ()
boxedPtrFree = \ContextMenu_
x -> ContextMenu_ -> (Ptr ContextMenu_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ContextMenu_
x Ptr ContextMenu_ -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ContextMenu_ where
    boxedPtrCalloc :: IO (Ptr ContextMenu_)
boxedPtrCalloc = Int -> IO (Ptr ContextMenu_)
forall a. Int -> IO (Ptr a)
callocBytes Int
32


-- | Construct a `ContextMenu_` struct initialized to zero.
newZeroContextMenu_ :: MonadIO m => m ContextMenu_
newZeroContextMenu_ :: forall (m :: * -> *). MonadIO m => m ContextMenu_
newZeroContextMenu_ = IO ContextMenu_ -> m ContextMenu_
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ContextMenu_ -> m ContextMenu_)
-> IO ContextMenu_ -> m ContextMenu_
forall a b. (a -> b) -> a -> b
$ IO (Ptr ContextMenu_)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ContextMenu_)
-> (Ptr ContextMenu_ -> IO ContextMenu_) -> IO ContextMenu_
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ContextMenu_ -> ContextMenu_)
-> Ptr ContextMenu_ -> IO ContextMenu_
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ContextMenu_ -> ContextMenu_
ContextMenu_

instance tag ~ 'AttrSet => Constructible ContextMenu_ tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ContextMenu_ -> ContextMenu_)
-> [AttrOp ContextMenu_ tag] -> m ContextMenu_
new ManagedPtr ContextMenu_ -> ContextMenu_
_ [AttrOp ContextMenu_ tag]
attrs = do
        ContextMenu_
o <- m ContextMenu_
forall (m :: * -> *). MonadIO m => m ContextMenu_
newZeroContextMenu_
        ContextMenu_ -> [AttrOp ContextMenu_ 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ContextMenu_
o [AttrOp ContextMenu_ tag]
[AttrOp ContextMenu_ 'AttrSet]
attrs
        ContextMenu_ -> m ContextMenu_
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ContextMenu_
o


-- | Get the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' contextMenu_ #parent
-- @
getContextMenu_Parent :: MonadIO m => ContextMenu_ -> m (Maybe GObject.Object.Object)
getContextMenu_Parent :: forall (m :: * -> *). MonadIO m => ContextMenu_ -> m (Maybe Object)
getContextMenu_Parent ContextMenu_
s = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ ContextMenu_
-> (Ptr ContextMenu_ -> IO (Maybe Object)) -> IO (Maybe Object)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContextMenu_
s ((Ptr ContextMenu_ -> IO (Maybe Object)) -> IO (Maybe Object))
-> (Ptr ContextMenu_ -> IO (Maybe Object)) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr ContextMenu_
ptr -> do
    Ptr Object
val <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ContextMenu_
ptr Ptr ContextMenu_ -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GObject.Object.Object)
    Maybe Object
result <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Object
val ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
val' -> do
        Object
val'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
val'
        Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
val''
    Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
result

-- | Set the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' contextMenu_ [ #parent 'Data.GI.Base.Attributes.:=' value ]
-- @
setContextMenu_Parent :: MonadIO m => ContextMenu_ -> Ptr GObject.Object.Object -> m ()
setContextMenu_Parent :: forall (m :: * -> *).
MonadIO m =>
ContextMenu_ -> Ptr Object -> m ()
setContextMenu_Parent ContextMenu_
s Ptr Object
val = 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
$ ContextMenu_ -> (Ptr ContextMenu_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContextMenu_
s ((Ptr ContextMenu_ -> IO ()) -> IO ())
-> (Ptr ContextMenu_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContextMenu_
ptr -> do
    Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContextMenu_
ptr Ptr ContextMenu_ -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr Object
val :: Ptr GObject.Object.Object)

-- | Set the value of the “@parent@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #parent
-- @
clearContextMenu_Parent :: MonadIO m => ContextMenu_ -> m ()
clearContextMenu_Parent :: forall (m :: * -> *). MonadIO m => ContextMenu_ -> m ()
clearContextMenu_Parent ContextMenu_
s = 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
$ ContextMenu_ -> (Ptr ContextMenu_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ContextMenu_
s ((Ptr ContextMenu_ -> IO ()) -> IO ())
-> (Ptr ContextMenu_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ContextMenu_
ptr -> do
    Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ContextMenu_
ptr Ptr ContextMenu_ -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr Object
forall a. Ptr a
FP.nullPtr :: Ptr GObject.Object.Object)

#if defined(ENABLE_OVERLOADING)
data ContextMenu_ParentFieldInfo
instance AttrInfo ContextMenu_ParentFieldInfo where
    type AttrBaseTypeConstraint ContextMenu_ParentFieldInfo = (~) ContextMenu_
    type AttrAllowedOps ContextMenu_ParentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ContextMenu_ParentFieldInfo = (~) (Ptr GObject.Object.Object)
    type AttrTransferTypeConstraint ContextMenu_ParentFieldInfo = (~)(Ptr GObject.Object.Object)
    type AttrTransferType ContextMenu_ParentFieldInfo = (Ptr GObject.Object.Object)
    type AttrGetType ContextMenu_ParentFieldInfo = Maybe GObject.Object.Object
    type AttrLabel ContextMenu_ParentFieldInfo = "parent"
    type AttrOrigin ContextMenu_ParentFieldInfo = ContextMenu_
    attrGet = getContextMenu_Parent
    attrSet = setContextMenu_Parent
    attrConstruct = undefined
    attrClear = clearContextMenu_Parent
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Structs.ContextMenu_.parent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.28/docs/GI-WebKit2WebExtension-Structs-ContextMenu_.html#g:attr:parent"
        })

contextMenu__parent :: AttrLabelProxy "parent"
contextMenu__parent = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContextMenu_
type instance O.AttributeList ContextMenu_ = ContextMenu_AttributeList
type ContextMenu_AttributeList = ('[ '("parent", ContextMenu_ParentFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveContextMenu_Method (t :: Symbol) (o :: *) :: * where
    ResolveContextMenu_Method l o = O.MethodResolutionFailed l o

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

#endif

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

#endif