{-# 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.WebKit2WebExtension.Objects.DOMClientRectList
    ( 

-- * Exported types
    DOMClientRectList(..)                   ,
    IsDOMClientRectList                     ,
    toDOMClientRectList                     ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveDOMClientRectListMethod          ,
#endif


-- ** getLength #method:getLength#

#if defined(ENABLE_OVERLOADING)
    DOMClientRectListGetLengthMethodInfo    ,
#endif
    dOMClientRectListGetLength              ,


-- ** item #method:item#

#if defined(ENABLE_OVERLOADING)
    DOMClientRectListItemMethodInfo         ,
#endif
    dOMClientRectListItem                   ,




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

#if defined(ENABLE_OVERLOADING)
    DOMClientRectListLengthPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMClientRectListLength                 ,
#endif
    getDOMClientRectListLength              ,




    ) 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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMClientRect as WebKit2WebExtension.DOMClientRect
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMObject as WebKit2WebExtension.DOMObject

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

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

foreign import ccall "webkit_dom_client_rect_list_get_type"
    c_webkit_dom_client_rect_list_get_type :: IO B.Types.GType

instance B.Types.TypedObject DOMClientRectList where
    glibType :: IO GType
glibType = IO GType
c_webkit_dom_client_rect_list_get_type

instance B.Types.GObject DOMClientRectList

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

-- | Type class for types which can be safely cast to `DOMClientRectList`, for instance with `toDOMClientRectList`.
class (SP.GObject o, O.IsDescendantOf DOMClientRectList o) => IsDOMClientRectList o
instance (SP.GObject o, O.IsDescendantOf DOMClientRectList o) => IsDOMClientRectList o

instance O.HasParentTypes DOMClientRectList
type instance O.ParentTypes DOMClientRectList = '[WebKit2WebExtension.DOMObject.DOMObject, GObject.Object.Object]

-- | Cast to `DOMClientRectList`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDOMClientRectList :: (MonadIO m, IsDOMClientRectList o) => o -> m DOMClientRectList
toDOMClientRectList :: o -> m DOMClientRectList
toDOMClientRectList = IO DOMClientRectList -> m DOMClientRectList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMClientRectList -> m DOMClientRectList)
-> (o -> IO DOMClientRectList) -> o -> m DOMClientRectList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DOMClientRectList -> DOMClientRectList)
-> o -> IO DOMClientRectList
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr DOMClientRectList -> DOMClientRectList
DOMClientRectList

#if defined(ENABLE_OVERLOADING)
type family ResolveDOMClientRectListMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMClientRectListMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMClientRectListMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMClientRectListMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMClientRectListMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMClientRectListMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDOMClientRectListMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMClientRectListMethod "item" o = DOMClientRectListItemMethodInfo
    ResolveDOMClientRectListMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMClientRectListMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMClientRectListMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMClientRectListMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMClientRectListMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMClientRectListMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMClientRectListMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMClientRectListMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMClientRectListMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMClientRectListMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMClientRectListMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMClientRectListMethod "getLength" o = DOMClientRectListGetLengthMethodInfo
    ResolveDOMClientRectListMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMClientRectListMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMClientRectListMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMClientRectListMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDOMClientRectListMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMClientRectListMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "length"
   -- Type: TBasicType TULong
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@length@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dOMClientRectList #length
-- @
getDOMClientRectListLength :: (MonadIO m, IsDOMClientRectList o) => o -> m CULong
getDOMClientRectListLength :: o -> m CULong
getDOMClientRectListLength o
obj = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CULong
forall a. GObject a => a -> String -> IO CULong
B.Properties.getObjectPropertyULong o
obj String
"length"

#if defined(ENABLE_OVERLOADING)
data DOMClientRectListLengthPropertyInfo
instance AttrInfo DOMClientRectListLengthPropertyInfo where
    type AttrAllowedOps DOMClientRectListLengthPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint DOMClientRectListLengthPropertyInfo = IsDOMClientRectList
    type AttrSetTypeConstraint DOMClientRectListLengthPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMClientRectListLengthPropertyInfo = (~) ()
    type AttrTransferType DOMClientRectListLengthPropertyInfo = ()
    type AttrGetType DOMClientRectListLengthPropertyInfo = CULong
    type AttrLabel DOMClientRectListLengthPropertyInfo = "length"
    type AttrOrigin DOMClientRectListLengthPropertyInfo = DOMClientRectList
    attrGet = getDOMClientRectListLength
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DOMClientRectList
type instance O.AttributeList DOMClientRectList = DOMClientRectListAttributeList
type DOMClientRectListAttributeList = ('[ '("coreObject", WebKit2WebExtension.DOMObject.DOMObjectCoreObjectPropertyInfo), '("length", DOMClientRectListLengthPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
dOMClientRectListLength :: AttrLabelProxy "length"
dOMClientRectListLength = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DOMClientRectList = DOMClientRectListSignalList
type DOMClientRectListSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DOMClientRectList::get_length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name
--                   { namespace = "WebKit2WebExtension" , name = "DOMClientRectList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMClientRectList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TULong)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_client_rect_list_get_length" webkit_dom_client_rect_list_get_length :: 
    Ptr DOMClientRectList ->                -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMClientRectList"})
    IO CULong

{-# DEPRECATED dOMClientRectListGetLength ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | Returns the number of t'GI.WebKit2WebExtension.Objects.DOMClientRect.DOMClientRect' objects that /@self@/ contains.
-- 
-- /Since: 2.18/
dOMClientRectListGetLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMClientRectList a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMClientRectList.DOMClientRectList'
    -> m CULong
    -- ^ __Returns:__ A @/gulong/@
dOMClientRectListGetLength :: a -> m CULong
dOMClientRectListGetLength a
self = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMClientRectList
self' <- a -> IO (Ptr DOMClientRectList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CULong
result <- Ptr DOMClientRectList -> IO CULong
webkit_dom_client_rect_list_get_length Ptr DOMClientRectList
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CULong -> IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
result

#if defined(ENABLE_OVERLOADING)
data DOMClientRectListGetLengthMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMClientRectList a) => O.MethodInfo DOMClientRectListGetLengthMethodInfo a signature where
    overloadedMethod = dOMClientRectListGetLength

#endif

-- method DOMClientRectList::item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name
--                   { namespace = "WebKit2WebExtension" , name = "DOMClientRectList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMClientRectList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index"
--           , argType = TBasicType TULong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #gulong" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name
--                    { namespace = "WebKit2WebExtension" , name = "DOMClientRect" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_client_rect_list_item" webkit_dom_client_rect_list_item :: 
    Ptr DOMClientRectList ->                -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMClientRectList"})
    CULong ->                               -- index : TBasicType TULong
    IO (Ptr WebKit2WebExtension.DOMClientRect.DOMClientRect)

{-# DEPRECATED dOMClientRectListItem ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | Returns the t'GI.WebKit2WebExtension.Objects.DOMClientRect.DOMClientRect' object that /@self@/ contains at /@index@/.
-- 
-- /Since: 2.18/
dOMClientRectListItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMClientRectList a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMClientRectList.DOMClientRectList'
    -> CULong
    -- ^ /@index@/: A @/gulong/@
    -> m WebKit2WebExtension.DOMClientRect.DOMClientRect
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMClientRect.DOMClientRect'
dOMClientRectListItem :: a -> CULong -> m DOMClientRect
dOMClientRectListItem a
self CULong
index = IO DOMClientRect -> m DOMClientRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMClientRect -> m DOMClientRect)
-> IO DOMClientRect -> m DOMClientRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMClientRectList
self' <- a -> IO (Ptr DOMClientRectList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMClientRect
result <- Ptr DOMClientRectList -> CULong -> IO (Ptr DOMClientRect)
webkit_dom_client_rect_list_item Ptr DOMClientRectList
self' CULong
index
    Text -> Ptr DOMClientRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dOMClientRectListItem" Ptr DOMClientRect
result
    DOMClientRect
result' <- ((ManagedPtr DOMClientRect -> DOMClientRect)
-> Ptr DOMClientRect -> IO DOMClientRect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DOMClientRect -> DOMClientRect
WebKit2WebExtension.DOMClientRect.DOMClientRect) Ptr DOMClientRect
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMClientRect -> IO DOMClientRect
forall (m :: * -> *) a. Monad m => a -> m a
return DOMClientRect
result'

#if defined(ENABLE_OVERLOADING)
data DOMClientRectListItemMethodInfo
instance (signature ~ (CULong -> m WebKit2WebExtension.DOMClientRect.DOMClientRect), MonadIO m, IsDOMClientRectList a) => O.MethodInfo DOMClientRectListItemMethodInfo a signature where
    overloadedMethod = dOMClientRectListItem

#endif