module GHCJS.DOM.JSFFI.Generated.TreeWalker
(js_parentNode, parentNode, parentNode_, parentNodeUnsafe,
parentNodeUnchecked, js_firstChild, firstChild, firstChild_,
firstChildUnsafe, firstChildUnchecked, js_lastChild, lastChild,
lastChild_, lastChildUnsafe, lastChildUnchecked,
js_previousSibling, previousSibling, previousSibling_,
previousSiblingUnsafe, previousSiblingUnchecked, js_nextSibling,
nextSibling, nextSibling_, nextSiblingUnsafe, nextSiblingUnchecked,
js_previousNode, previousNode, previousNode_, previousNodeUnsafe,
previousNodeUnchecked, js_nextNode, nextNode, nextNode_,
nextNodeUnsafe, nextNodeUnchecked, js_getRoot, getRoot,
getRootUnsafe, getRootUnchecked, js_getWhatToShow, getWhatToShow,
js_getFilter, getFilter, getFilterUnsafe, getFilterUnchecked,
js_getExpandEntityReferences, getExpandEntityReferences,
js_setCurrentNode, setCurrentNode, js_getCurrentNode,
getCurrentNode, getCurrentNodeUnsafe, getCurrentNodeUnchecked,
TreeWalker(..), gTypeTreeWalker)
where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import qualified Prelude (error)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull)
import GHCJS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import Data.Maybe (fromJust)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
import GHCJS.DOM.JSFFI.Generated.Enums
foreign import javascript unsafe "$1[\"parentNode\"]()"
js_parentNode :: TreeWalker -> IO (Nullable Node)
parentNode :: (MonadIO m) => TreeWalker -> m (Maybe Node)
parentNode self
= liftIO (nullableToMaybe <$> (js_parentNode (self)))
parentNode_ :: (MonadIO m) => TreeWalker -> m ()
parentNode_ self = liftIO (void (js_parentNode (self)))
parentNodeUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
parentNodeUnsafe self
= liftIO
((nullableToMaybe <$> (js_parentNode (self))) >>=
maybe (Prelude.error "Nothing to return") return)
parentNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
parentNodeUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_parentNode (self)))
foreign import javascript unsafe "$1[\"firstChild\"]()"
js_firstChild :: TreeWalker -> IO (Nullable Node)
firstChild :: (MonadIO m) => TreeWalker -> m (Maybe Node)
firstChild self
= liftIO (nullableToMaybe <$> (js_firstChild (self)))
firstChild_ :: (MonadIO m) => TreeWalker -> m ()
firstChild_ self = liftIO (void (js_firstChild (self)))
firstChildUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
firstChildUnsafe self
= liftIO
((nullableToMaybe <$> (js_firstChild (self))) >>=
maybe (Prelude.error "Nothing to return") return)
firstChildUnchecked :: (MonadIO m) => TreeWalker -> m Node
firstChildUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_firstChild (self)))
foreign import javascript unsafe "$1[\"lastChild\"]()" js_lastChild
:: TreeWalker -> IO (Nullable Node)
lastChild :: (MonadIO m) => TreeWalker -> m (Maybe Node)
lastChild self = liftIO (nullableToMaybe <$> (js_lastChild (self)))
lastChild_ :: (MonadIO m) => TreeWalker -> m ()
lastChild_ self = liftIO (void (js_lastChild (self)))
lastChildUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
lastChildUnsafe self
= liftIO
((nullableToMaybe <$> (js_lastChild (self))) >>=
maybe (Prelude.error "Nothing to return") return)
lastChildUnchecked :: (MonadIO m) => TreeWalker -> m Node
lastChildUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_lastChild (self)))
foreign import javascript unsafe "$1[\"previousSibling\"]()"
js_previousSibling :: TreeWalker -> IO (Nullable Node)
previousSibling :: (MonadIO m) => TreeWalker -> m (Maybe Node)
previousSibling self
= liftIO (nullableToMaybe <$> (js_previousSibling (self)))
previousSibling_ :: (MonadIO m) => TreeWalker -> m ()
previousSibling_ self = liftIO (void (js_previousSibling (self)))
previousSiblingUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
previousSiblingUnsafe self
= liftIO
((nullableToMaybe <$> (js_previousSibling (self))) >>=
maybe (Prelude.error "Nothing to return") return)
previousSiblingUnchecked :: (MonadIO m) => TreeWalker -> m Node
previousSiblingUnchecked self
= liftIO
(fromJust . nullableToMaybe <$> (js_previousSibling (self)))
foreign import javascript unsafe "$1[\"nextSibling\"]()"
js_nextSibling :: TreeWalker -> IO (Nullable Node)
nextSibling :: (MonadIO m) => TreeWalker -> m (Maybe Node)
nextSibling self
= liftIO (nullableToMaybe <$> (js_nextSibling (self)))
nextSibling_ :: (MonadIO m) => TreeWalker -> m ()
nextSibling_ self = liftIO (void (js_nextSibling (self)))
nextSiblingUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
nextSiblingUnsafe self
= liftIO
((nullableToMaybe <$> (js_nextSibling (self))) >>=
maybe (Prelude.error "Nothing to return") return)
nextSiblingUnchecked :: (MonadIO m) => TreeWalker -> m Node
nextSiblingUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_nextSibling (self)))
foreign import javascript unsafe "$1[\"previousNode\"]()"
js_previousNode :: TreeWalker -> IO (Nullable Node)
previousNode :: (MonadIO m) => TreeWalker -> m (Maybe Node)
previousNode self
= liftIO (nullableToMaybe <$> (js_previousNode (self)))
previousNode_ :: (MonadIO m) => TreeWalker -> m ()
previousNode_ self = liftIO (void (js_previousNode (self)))
previousNodeUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
previousNodeUnsafe self
= liftIO
((nullableToMaybe <$> (js_previousNode (self))) >>=
maybe (Prelude.error "Nothing to return") return)
previousNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
previousNodeUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_previousNode (self)))
foreign import javascript unsafe "$1[\"nextNode\"]()" js_nextNode
:: TreeWalker -> IO (Nullable Node)
nextNode :: (MonadIO m) => TreeWalker -> m (Maybe Node)
nextNode self = liftIO (nullableToMaybe <$> (js_nextNode (self)))
nextNode_ :: (MonadIO m) => TreeWalker -> m ()
nextNode_ self = liftIO (void (js_nextNode (self)))
nextNodeUnsafe :: (MonadIO m, HasCallStack) => TreeWalker -> m Node
nextNodeUnsafe self
= liftIO
((nullableToMaybe <$> (js_nextNode (self))) >>=
maybe (Prelude.error "Nothing to return") return)
nextNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
nextNodeUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_nextNode (self)))
foreign import javascript unsafe "$1[\"root\"]" js_getRoot ::
TreeWalker -> IO (Nullable Node)
getRoot :: (MonadIO m) => TreeWalker -> m (Maybe Node)
getRoot self = liftIO (nullableToMaybe <$> (js_getRoot (self)))
getRootUnsafe :: (MonadIO m, HasCallStack) => TreeWalker -> m Node
getRootUnsafe self
= liftIO
((nullableToMaybe <$> (js_getRoot (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getRootUnchecked :: (MonadIO m) => TreeWalker -> m Node
getRootUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getRoot (self)))
foreign import javascript unsafe "$1[\"whatToShow\"]"
js_getWhatToShow :: TreeWalker -> IO Word
getWhatToShow :: (MonadIO m) => TreeWalker -> m Word
getWhatToShow self = liftIO (js_getWhatToShow (self))
foreign import javascript unsafe "$1[\"filter\"]" js_getFilter ::
TreeWalker -> IO (Nullable NodeFilter)
getFilter :: (MonadIO m) => TreeWalker -> m (Maybe NodeFilter)
getFilter self = liftIO (nullableToMaybe <$> (js_getFilter (self)))
getFilterUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m NodeFilter
getFilterUnsafe self
= liftIO
((nullableToMaybe <$> (js_getFilter (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getFilterUnchecked :: (MonadIO m) => TreeWalker -> m NodeFilter
getFilterUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getFilter (self)))
foreign import javascript unsafe
"($1[\"expandEntityReferences\"] ? 1 : 0)"
js_getExpandEntityReferences :: TreeWalker -> IO Bool
getExpandEntityReferences :: (MonadIO m) => TreeWalker -> m Bool
getExpandEntityReferences self
= liftIO (js_getExpandEntityReferences (self))
foreign import javascript unsafe "$1[\"currentNode\"] = $2;"
js_setCurrentNode :: TreeWalker -> Nullable Node -> IO ()
setCurrentNode ::
(MonadIO m, IsNode val) => TreeWalker -> Maybe val -> m ()
setCurrentNode self val
= liftIO
(js_setCurrentNode (self) (maybeToNullable (fmap toNode val)))
foreign import javascript unsafe "$1[\"currentNode\"]"
js_getCurrentNode :: TreeWalker -> IO (Nullable Node)
getCurrentNode :: (MonadIO m) => TreeWalker -> m (Maybe Node)
getCurrentNode self
= liftIO (nullableToMaybe <$> (js_getCurrentNode (self)))
getCurrentNodeUnsafe ::
(MonadIO m, HasCallStack) => TreeWalker -> m Node
getCurrentNodeUnsafe self
= liftIO
((nullableToMaybe <$> (js_getCurrentNode (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getCurrentNodeUnchecked :: (MonadIO m) => TreeWalker -> m Node
getCurrentNodeUnchecked self
= liftIO
(fromJust . nullableToMaybe <$> (js_getCurrentNode (self)))