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

-- * Exported types
    DOMTreeWalker(..)                       ,
    IsDOMTreeWalker                         ,
    toDOMTreeWalker                         ,
    noDOMTreeWalker                         ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveDOMTreeWalkerMethod              ,
#endif


-- ** firstChild #method:firstChild#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerFirstChildMethodInfo       ,
#endif
    dOMTreeWalkerFirstChild                 ,


-- ** getCurrentNode #method:getCurrentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerGetCurrentNode             ,


-- ** getExpandEntityReferences #method:getExpandEntityReferences#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetExpandEntityReferencesMethodInfo,
#endif
    dOMTreeWalkerGetExpandEntityReferences  ,


-- ** getFilter #method:getFilter#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetFilterMethodInfo        ,
#endif
    dOMTreeWalkerGetFilter                  ,


-- ** getRoot #method:getRoot#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetRootMethodInfo          ,
#endif
    dOMTreeWalkerGetRoot                    ,


-- ** getWhatToShow #method:getWhatToShow#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerGetWhatToShowMethodInfo    ,
#endif
    dOMTreeWalkerGetWhatToShow              ,


-- ** lastChild #method:lastChild#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerLastChildMethodInfo        ,
#endif
    dOMTreeWalkerLastChild                  ,


-- ** nextNode #method:nextNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerNextNodeMethodInfo         ,
#endif
    dOMTreeWalkerNextNode                   ,


-- ** nextSibling #method:nextSibling#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerNextSiblingMethodInfo      ,
#endif
    dOMTreeWalkerNextSibling                ,


-- ** parentNode #method:parentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerParentNodeMethodInfo       ,
#endif
    dOMTreeWalkerParentNode                 ,


-- ** previousNode #method:previousNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerPreviousNodeMethodInfo     ,
#endif
    dOMTreeWalkerPreviousNode               ,


-- ** previousSibling #method:previousSibling#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerPreviousSiblingMethodInfo  ,
#endif
    dOMTreeWalkerPreviousSibling            ,


-- ** setCurrentNode #method:setCurrentNode#

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerSetCurrentNodeMethodInfo   ,
#endif
    dOMTreeWalkerSetCurrentNode             ,




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

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerCurrentNodePropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerCurrentNode                ,
#endif
    getDOMTreeWalkerCurrentNode             ,


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

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerFilterPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerFilter                     ,
#endif
    getDOMTreeWalkerFilter                  ,


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

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerRootPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerRoot                       ,
#endif
    getDOMTreeWalkerRoot                    ,


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

#if defined(ENABLE_OVERLOADING)
    DOMTreeWalkerWhatToShowPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    dOMTreeWalkerWhatToShow                 ,
#endif
    getDOMTreeWalkerWhatToShow              ,




    ) 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.GI.Base.Signals as B.Signals
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.Interfaces.DOMNodeFilter as WebKit2WebExtension.DOMNodeFilter
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMNode as WebKit2WebExtension.DOMNode
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMObject as WebKit2WebExtension.DOMObject

-- | Memory-managed wrapper type.
newtype DOMTreeWalker = DOMTreeWalker (ManagedPtr DOMTreeWalker)
    deriving (DOMTreeWalker -> DOMTreeWalker -> Bool
(DOMTreeWalker -> DOMTreeWalker -> Bool)
-> (DOMTreeWalker -> DOMTreeWalker -> Bool) -> Eq DOMTreeWalker
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMTreeWalker -> DOMTreeWalker -> Bool
$c/= :: DOMTreeWalker -> DOMTreeWalker -> Bool
== :: DOMTreeWalker -> DOMTreeWalker -> Bool
$c== :: DOMTreeWalker -> DOMTreeWalker -> Bool
Eq)
foreign import ccall "webkit_dom_tree_walker_get_type"
    c_webkit_dom_tree_walker_get_type :: IO GType

instance GObject DOMTreeWalker where
    gobjectType :: IO GType
gobjectType = IO GType
c_webkit_dom_tree_walker_get_type
    

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

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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `DOMTreeWalker`.
noDOMTreeWalker :: Maybe DOMTreeWalker
noDOMTreeWalker :: Maybe DOMTreeWalker
noDOMTreeWalker = Maybe DOMTreeWalker
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveDOMTreeWalkerMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMTreeWalkerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMTreeWalkerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMTreeWalkerMethod "firstChild" o = DOMTreeWalkerFirstChildMethodInfo
    ResolveDOMTreeWalkerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMTreeWalkerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDOMTreeWalkerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMTreeWalkerMethod "lastChild" o = DOMTreeWalkerLastChildMethodInfo
    ResolveDOMTreeWalkerMethod "nextNode" o = DOMTreeWalkerNextNodeMethodInfo
    ResolveDOMTreeWalkerMethod "nextSibling" o = DOMTreeWalkerNextSiblingMethodInfo
    ResolveDOMTreeWalkerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMTreeWalkerMethod "parentNode" o = DOMTreeWalkerParentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "previousNode" o = DOMTreeWalkerPreviousNodeMethodInfo
    ResolveDOMTreeWalkerMethod "previousSibling" o = DOMTreeWalkerPreviousSiblingMethodInfo
    ResolveDOMTreeWalkerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMTreeWalkerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMTreeWalkerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMTreeWalkerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMTreeWalkerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMTreeWalkerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMTreeWalkerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMTreeWalkerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMTreeWalkerMethod "getCurrentNode" o = DOMTreeWalkerGetCurrentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMTreeWalkerMethod "getExpandEntityReferences" o = DOMTreeWalkerGetExpandEntityReferencesMethodInfo
    ResolveDOMTreeWalkerMethod "getFilter" o = DOMTreeWalkerGetFilterMethodInfo
    ResolveDOMTreeWalkerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMTreeWalkerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMTreeWalkerMethod "getRoot" o = DOMTreeWalkerGetRootMethodInfo
    ResolveDOMTreeWalkerMethod "getWhatToShow" o = DOMTreeWalkerGetWhatToShowMethodInfo
    ResolveDOMTreeWalkerMethod "setCurrentNode" o = DOMTreeWalkerSetCurrentNodeMethodInfo
    ResolveDOMTreeWalkerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMTreeWalkerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDOMTreeWalkerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMTreeWalkerMethod l o = O.MethodResolutionFailed l o

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

#endif

-- VVV Prop "current-node"
   -- Type: TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNode"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@current-node@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dOMTreeWalker #currentNode
-- @
getDOMTreeWalkerCurrentNode :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerCurrentNode :: o -> m DOMNode
getDOMTreeWalkerCurrentNode obj :: o
obj = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe DOMNode) -> IO DOMNode
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getDOMTreeWalkerCurrentNode" (IO (Maybe DOMNode) -> IO DOMNode)
-> IO (Maybe DOMNode) -> IO DOMNode
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr DOMNode -> DOMNode) -> IO (Maybe DOMNode)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "current-node" ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerCurrentNodePropertyInfo
instance AttrInfo DOMTreeWalkerCurrentNodePropertyInfo where
    type AttrAllowedOps DOMTreeWalkerCurrentNodePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerCurrentNodePropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerCurrentNodePropertyInfo = ()
    type AttrGetType DOMTreeWalkerCurrentNodePropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerCurrentNodePropertyInfo = "current-node"
    type AttrOrigin DOMTreeWalkerCurrentNodePropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerCurrentNode
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "filter"
   -- Type: TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNodeFilter"})
   -- 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' dOMTreeWalker #filter
-- @
getDOMTreeWalkerFilter :: (MonadIO m, IsDOMTreeWalker o) => o -> m (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
getDOMTreeWalkerFilter :: o -> m (Maybe DOMNodeFilter)
getDOMTreeWalkerFilter obj :: o
obj = IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter))
-> IO (Maybe DOMNodeFilter) -> m (Maybe DOMNodeFilter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr DOMNodeFilter -> DOMNodeFilter)
-> IO (Maybe DOMNodeFilter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "filter" ManagedPtr DOMNodeFilter -> DOMNodeFilter
WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerFilterPropertyInfo
instance AttrInfo DOMTreeWalkerFilterPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerFilterPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerFilterPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerFilterPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerFilterPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerFilterPropertyInfo = ()
    type AttrGetType DOMTreeWalkerFilterPropertyInfo = (Maybe WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)
    type AttrLabel DOMTreeWalkerFilterPropertyInfo = "filter"
    type AttrOrigin DOMTreeWalkerFilterPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerFilter
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "root"
   -- Type: TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNode"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@root@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dOMTreeWalker #root
-- @
getDOMTreeWalkerRoot :: (MonadIO m, IsDOMTreeWalker o) => o -> m WebKit2WebExtension.DOMNode.DOMNode
getDOMTreeWalkerRoot :: o -> m DOMNode
getDOMTreeWalkerRoot obj :: o
obj = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe DOMNode) -> IO DOMNode
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getDOMTreeWalkerRoot" (IO (Maybe DOMNode) -> IO DOMNode)
-> IO (Maybe DOMNode) -> IO DOMNode
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr DOMNode -> DOMNode) -> IO (Maybe DOMNode)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "root" ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerRootPropertyInfo
instance AttrInfo DOMTreeWalkerRootPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerRootPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DOMTreeWalkerRootPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerRootPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerRootPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerRootPropertyInfo = ()
    type AttrGetType DOMTreeWalkerRootPropertyInfo = WebKit2WebExtension.DOMNode.DOMNode
    type AttrLabel DOMTreeWalkerRootPropertyInfo = "root"
    type AttrOrigin DOMTreeWalkerRootPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerRoot
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

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

-- | Get the value of the “@what-to-show@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dOMTreeWalker #whatToShow
-- @
getDOMTreeWalkerWhatToShow :: (MonadIO m, IsDOMTreeWalker o) => o -> m CULong
getDOMTreeWalkerWhatToShow :: o -> m CULong
getDOMTreeWalkerWhatToShow obj :: 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 "what-to-show"

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerWhatToShowPropertyInfo
instance AttrInfo DOMTreeWalkerWhatToShowPropertyInfo where
    type AttrAllowedOps DOMTreeWalkerWhatToShowPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = IsDOMTreeWalker
    type AttrSetTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DOMTreeWalkerWhatToShowPropertyInfo = (~) ()
    type AttrTransferType DOMTreeWalkerWhatToShowPropertyInfo = ()
    type AttrGetType DOMTreeWalkerWhatToShowPropertyInfo = CULong
    type AttrLabel DOMTreeWalkerWhatToShowPropertyInfo = "what-to-show"
    type AttrOrigin DOMTreeWalkerWhatToShowPropertyInfo = DOMTreeWalker
    attrGet = getDOMTreeWalkerWhatToShow
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DOMTreeWalker
type instance O.AttributeList DOMTreeWalker = DOMTreeWalkerAttributeList
type DOMTreeWalkerAttributeList = ('[ '("coreObject", WebKit2WebExtension.DOMObject.DOMObjectCoreObjectPropertyInfo), '("currentNode", DOMTreeWalkerCurrentNodePropertyInfo), '("filter", DOMTreeWalkerFilterPropertyInfo), '("root", DOMTreeWalkerRootPropertyInfo), '("whatToShow", DOMTreeWalkerWhatToShowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
dOMTreeWalkerCurrentNode :: AttrLabelProxy "currentNode"
dOMTreeWalkerCurrentNode = AttrLabelProxy

dOMTreeWalkerFilter :: AttrLabelProxy "filter"
dOMTreeWalkerFilter = AttrLabelProxy

dOMTreeWalkerRoot :: AttrLabelProxy "root"
dOMTreeWalkerRoot = AttrLabelProxy

dOMTreeWalkerWhatToShow :: AttrLabelProxy "whatToShow"
dOMTreeWalkerWhatToShow = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "webkit_dom_tree_walker_first_child" webkit_dom_tree_walker_first_child :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerFirstChild ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerFirstChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerFirstChild :: a -> m DOMNode
dOMTreeWalkerFirstChild self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_first_child Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerFirstChild" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerFirstChildMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerFirstChildMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerFirstChild

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_current_node" webkit_dom_tree_walker_get_current_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerGetCurrentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerGetCurrentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerGetCurrentNode :: a -> m DOMNode
dOMTreeWalkerGetCurrentNode self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_get_current_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerGetCurrentNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerGetCurrentNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetCurrentNodeMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerGetCurrentNode

#endif

-- method DOMTreeWalker::get_expand_entity_references
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2WebExtension" , name = "DOMTreeWalker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMTreeWalker"
--                 , 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_dom_tree_walker_get_expand_entity_references" webkit_dom_tree_walker_get_expand_entity_references :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO CInt

{-# DEPRECATED dOMTreeWalkerGetExpandEntityReferences ["(Since version 2.12)"] #-}
-- | This function has been removed from the DOM spec and it just returns 'P.False'.
dOMTreeWalkerGetExpandEntityReferences ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m Bool
    -- ^ __Returns:__ A t'P.Bool'
dOMTreeWalkerGetExpandEntityReferences :: a -> m Bool
dOMTreeWalkerGetExpandEntityReferences self :: a
self = IO Bool -> m Bool
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 DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DOMTreeWalker -> IO CInt
webkit_dom_tree_walker_get_expand_entity_references Ptr DOMTreeWalker
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerGetExpandEntityReferencesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetExpandEntityReferencesMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerGetExpandEntityReferences

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_filter" webkit_dom_tree_walker_get_filter :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter)

{-# DEPRECATED dOMTreeWalkerGetFilter ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerGetFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Interfaces.DOMNodeFilter.DOMNodeFilter'
dOMTreeWalkerGetFilter :: a -> m DOMNodeFilter
dOMTreeWalkerGetFilter self :: a
self = IO DOMNodeFilter -> m DOMNodeFilter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNodeFilter -> m DOMNodeFilter)
-> IO DOMNodeFilter -> m DOMNodeFilter
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNodeFilter
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNodeFilter)
webkit_dom_tree_walker_get_filter Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNodeFilter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerGetFilter" Ptr DOMNodeFilter
result
    DOMNodeFilter
result' <- ((ManagedPtr DOMNodeFilter -> DOMNodeFilter)
-> Ptr DOMNodeFilter -> IO DOMNodeFilter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DOMNodeFilter -> DOMNodeFilter
WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter) Ptr DOMNodeFilter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNodeFilter -> IO DOMNodeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNodeFilter
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerGetFilterMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNodeFilter.DOMNodeFilter), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetFilterMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerGetFilter

#endif

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

foreign import ccall "webkit_dom_tree_walker_get_root" webkit_dom_tree_walker_get_root :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerGetRoot ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerGetRoot :: a -> m DOMNode
dOMTreeWalkerGetRoot self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_get_root Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerGetRoot" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerGetRootMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetRootMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerGetRoot

#endif

-- method DOMTreeWalker::get_what_to_show
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2WebExtension" , name = "DOMTreeWalker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMTreeWalker"
--                 , 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_tree_walker_get_what_to_show" webkit_dom_tree_walker_get_what_to_show :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO CULong

{-# DEPRECATED dOMTreeWalkerGetWhatToShow ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerGetWhatToShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m CULong
    -- ^ __Returns:__ A @/gulong/@
dOMTreeWalkerGetWhatToShow :: a -> m CULong
dOMTreeWalkerGetWhatToShow self :: 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 DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CULong
result <- Ptr DOMTreeWalker -> IO CULong
webkit_dom_tree_walker_get_what_to_show Ptr DOMTreeWalker
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 DOMTreeWalkerGetWhatToShowMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerGetWhatToShowMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerGetWhatToShow

#endif

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

foreign import ccall "webkit_dom_tree_walker_last_child" webkit_dom_tree_walker_last_child :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerLastChild ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerLastChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerLastChild :: a -> m DOMNode
dOMTreeWalkerLastChild self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_last_child Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerLastChild" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerLastChildMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerLastChildMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerLastChild

#endif

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

foreign import ccall "webkit_dom_tree_walker_next_node" webkit_dom_tree_walker_next_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerNextNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerNextNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerNextNode :: a -> m DOMNode
dOMTreeWalkerNextNode self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_next_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerNextNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerNextNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerNextNodeMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerNextNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_next_sibling" webkit_dom_tree_walker_next_sibling :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerNextSibling ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerNextSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerNextSibling :: a -> m DOMNode
dOMTreeWalkerNextSibling self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_next_sibling Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerNextSibling" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerNextSiblingMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerNextSiblingMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerNextSibling

#endif

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

foreign import ccall "webkit_dom_tree_walker_parent_node" webkit_dom_tree_walker_parent_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerParentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerParentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerParentNode :: a -> m DOMNode
dOMTreeWalkerParentNode self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_parent_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerParentNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerParentNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerParentNodeMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerParentNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_previous_node" webkit_dom_tree_walker_previous_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerPreviousNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerPreviousNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerPreviousNode :: a -> m DOMNode
dOMTreeWalkerPreviousNode self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_previous_node Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerPreviousNode" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerPreviousNodeMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerPreviousNodeMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerPreviousNode

#endif

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

foreign import ccall "webkit_dom_tree_walker_previous_sibling" webkit_dom_tree_walker_previous_sibling :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    IO (Ptr WebKit2WebExtension.DOMNode.DOMNode)

{-# DEPRECATED dOMTreeWalkerPreviousSibling ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerPreviousSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> m WebKit2WebExtension.DOMNode.DOMNode
    -- ^ __Returns:__ A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
dOMTreeWalkerPreviousSibling :: a -> m DOMNode
dOMTreeWalkerPreviousSibling self :: a
self = IO DOMNode -> m DOMNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DOMNode -> m DOMNode) -> IO DOMNode -> m DOMNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
result <- Ptr DOMTreeWalker -> IO (Ptr DOMNode)
webkit_dom_tree_walker_previous_sibling Ptr DOMTreeWalker
self'
    Text -> Ptr DOMNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dOMTreeWalkerPreviousSibling" Ptr DOMNode
result
    DOMNode
result' <- ((ManagedPtr DOMNode -> DOMNode) -> Ptr DOMNode -> IO DOMNode
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMNode -> DOMNode
WebKit2WebExtension.DOMNode.DOMNode) Ptr DOMNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    DOMNode -> IO DOMNode
forall (m :: * -> *) a. Monad m => a -> m a
return DOMNode
result'

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerPreviousSiblingMethodInfo
instance (signature ~ (m WebKit2WebExtension.DOMNode.DOMNode), MonadIO m, IsDOMTreeWalker a) => O.MethodInfo DOMTreeWalkerPreviousSiblingMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerPreviousSibling

#endif

-- method DOMTreeWalker::set_current_node
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2WebExtension" , name = "DOMTreeWalker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMTreeWalker"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2WebExtension" , name = "DOMNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitDOMNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_tree_walker_set_current_node" webkit_dom_tree_walker_set_current_node :: 
    Ptr DOMTreeWalker ->                    -- self : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMTreeWalker"})
    Ptr WebKit2WebExtension.DOMNode.DOMNode -> -- value : TInterface (Name {namespace = "WebKit2WebExtension", name = "DOMNode"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

{-# DEPRECATED dOMTreeWalkerSetCurrentNode ["(Since version 2.22)","Use JavaScriptCore API instead"] #-}
-- | /No description available in the introspection data./
dOMTreeWalkerSetCurrentNode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTreeWalker a, WebKit2WebExtension.DOMNode.IsDOMNode b) =>
    a
    -- ^ /@self@/: A t'GI.WebKit2WebExtension.Objects.DOMTreeWalker.DOMTreeWalker'
    -> b
    -- ^ /@value@/: A t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
dOMTreeWalkerSetCurrentNode :: a -> b -> m ()
dOMTreeWalkerSetCurrentNode self :: a
self value :: b
value = 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 DOMTreeWalker
self' <- a -> IO (Ptr DOMTreeWalker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DOMNode
value' <- b -> IO (Ptr DOMNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
value
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr DOMTreeWalker -> Ptr DOMNode -> Ptr (Ptr GError) -> IO ()
webkit_dom_tree_walker_set_current_node Ptr DOMTreeWalker
self' Ptr DOMNode
value'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
value
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data DOMTreeWalkerSetCurrentNodeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTreeWalker a, WebKit2WebExtension.DOMNode.IsDOMNode b) => O.MethodInfo DOMTreeWalkerSetCurrentNodeMethodInfo a signature where
    overloadedMethod = dOMTreeWalkerSetCurrentNode

#endif