mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-06 12:43:53 +00:00
291 lines
7.1 KiB
C++
291 lines
7.1 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* Implementation of DOM Traversal's nsIDOMNodeIterator
|
|
*/
|
|
|
|
#include "mozilla/dom/NodeIterator.h"
|
|
|
|
#include "nsIDOMNode.h"
|
|
#include "nsError.h"
|
|
|
|
#include "nsIContent.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "mozilla/dom/NodeIteratorBinding.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
/*
|
|
* NodePointer implementation
|
|
*/
|
|
NodeIterator::NodePointer::NodePointer(nsINode *aNode, bool aBeforeNode) :
|
|
mNode(aNode),
|
|
mBeforeNode(aBeforeNode)
|
|
{
|
|
}
|
|
|
|
bool NodeIterator::NodePointer::MoveToNext(nsINode *aRoot)
|
|
{
|
|
if (!mNode)
|
|
return false;
|
|
|
|
if (mBeforeNode) {
|
|
mBeforeNode = false;
|
|
return true;
|
|
}
|
|
|
|
nsINode* child = mNode->GetFirstChild();
|
|
if (child) {
|
|
mNode = child;
|
|
return true;
|
|
}
|
|
|
|
return MoveForward(aRoot, mNode);
|
|
}
|
|
|
|
bool NodeIterator::NodePointer::MoveToPrevious(nsINode *aRoot)
|
|
{
|
|
if (!mNode)
|
|
return false;
|
|
|
|
if (!mBeforeNode) {
|
|
mBeforeNode = true;
|
|
return true;
|
|
}
|
|
|
|
if (mNode == aRoot)
|
|
return false;
|
|
|
|
MoveBackward(mNode->GetParentNode(), mNode->GetPreviousSibling());
|
|
|
|
return true;
|
|
}
|
|
|
|
void NodeIterator::NodePointer::AdjustAfterRemoval(nsINode *aRoot,
|
|
nsINode *aContainer,
|
|
nsIContent *aChild,
|
|
nsIContent *aPreviousSibling)
|
|
{
|
|
// If mNode is null or the root there is nothing to do.
|
|
if (!mNode || mNode == aRoot)
|
|
return;
|
|
|
|
// check if ancestor was removed
|
|
if (!nsContentUtils::ContentIsDescendantOf(mNode, aChild))
|
|
return;
|
|
|
|
if (mBeforeNode) {
|
|
|
|
// Try the next sibling
|
|
nsINode *nextSibling = aPreviousSibling ? aPreviousSibling->GetNextSibling()
|
|
: aContainer->GetFirstChild();
|
|
|
|
if (nextSibling) {
|
|
mNode = nextSibling;
|
|
return;
|
|
}
|
|
|
|
// Next try siblings of ancestors
|
|
if (MoveForward(aRoot, aContainer))
|
|
return;
|
|
|
|
// No suitable node was found so try going backwards
|
|
mBeforeNode = false;
|
|
}
|
|
|
|
MoveBackward(aContainer, aPreviousSibling);
|
|
}
|
|
|
|
bool NodeIterator::NodePointer::MoveForward(nsINode *aRoot, nsINode *aNode)
|
|
{
|
|
while (1) {
|
|
if (aNode == aRoot)
|
|
break;
|
|
|
|
nsINode *sibling = aNode->GetNextSibling();
|
|
if (sibling) {
|
|
mNode = sibling;
|
|
return true;
|
|
}
|
|
aNode = aNode->GetParentNode();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void NodeIterator::NodePointer::MoveBackward(nsINode *aParent, nsINode *aNode)
|
|
{
|
|
if (aNode) {
|
|
do {
|
|
mNode = aNode;
|
|
aNode = aNode->GetLastChild();
|
|
} while (aNode);
|
|
} else {
|
|
mNode = aParent;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Factories, constructors and destructors
|
|
*/
|
|
|
|
NodeIterator::NodeIterator(nsINode *aRoot,
|
|
uint32_t aWhatToShow,
|
|
NodeFilterHolder aFilter) :
|
|
nsTraversal(aRoot, aWhatToShow, Move(aFilter)),
|
|
mPointer(mRoot, true)
|
|
{
|
|
aRoot->AddMutationObserver(this);
|
|
}
|
|
|
|
NodeIterator::~NodeIterator()
|
|
{
|
|
/* destructor code */
|
|
if (mRoot)
|
|
mRoot->RemoveMutationObserver(this);
|
|
}
|
|
|
|
/*
|
|
* nsISupports and cycle collection stuff
|
|
*/
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(NodeIterator)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(NodeIterator)
|
|
if (tmp->mRoot)
|
|
tmp->mRoot->RemoveMutationObserver(tmp);
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mRoot)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mFilter)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(NodeIterator)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFilter)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
// QueryInterface implementation for NodeIterator
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(NodeIterator)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMNodeIterator)
|
|
NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMNodeIterator)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(NodeIterator)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(NodeIterator)
|
|
|
|
NS_IMETHODIMP NodeIterator::GetRoot(nsIDOMNode * *aRoot)
|
|
{
|
|
nsCOMPtr<nsIDOMNode> root = Root()->AsDOMNode();
|
|
root.forget(aRoot);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::GetWhatToShow(uint32_t *aWhatToShow)
|
|
{
|
|
*aWhatToShow = WhatToShow();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::GetFilter(nsIDOMNodeFilter **aFilter)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aFilter);
|
|
|
|
*aFilter = mFilter.ToXPCOMCallback().take();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::NextNode(nsIDOMNode **_retval)
|
|
{
|
|
return ImplNodeGetter(&NodeIterator::NextNode, _retval);
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::PreviousNode(nsIDOMNode **_retval)
|
|
{
|
|
return ImplNodeGetter(&NodeIterator::PreviousNode, _retval);
|
|
}
|
|
|
|
already_AddRefed<nsINode>
|
|
NodeIterator::NextOrPrevNode(NodePointer::MoveToMethodType aMove,
|
|
ErrorResult& aResult)
|
|
{
|
|
if (mInAcceptNode) {
|
|
aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
mWorkingPointer = mPointer;
|
|
|
|
struct AutoClear {
|
|
NodePointer* mPtr;
|
|
explicit AutoClear(NodePointer* ptr) : mPtr(ptr) {}
|
|
~AutoClear() { mPtr->Clear(); }
|
|
} ac(&mWorkingPointer);
|
|
|
|
while ((mWorkingPointer.*aMove)(mRoot)) {
|
|
nsCOMPtr<nsINode> testNode = mWorkingPointer.mNode;
|
|
int16_t filtered = TestNode(testNode, aResult);
|
|
if (aResult.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
|
|
mPointer = mWorkingPointer;
|
|
return testNode.forget();
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::Detach(void)
|
|
{
|
|
if (mRoot) {
|
|
mRoot->OwnerDoc()->WarnOnceAbout(nsIDocument::eNodeIteratorDetach);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::GetReferenceNode(nsIDOMNode * *aRefNode)
|
|
{
|
|
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(GetReferenceNode()));
|
|
node.forget(aRefNode);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP NodeIterator::GetPointerBeforeReferenceNode(bool *aBeforeNode)
|
|
{
|
|
*aBeforeNode = PointerBeforeReferenceNode();
|
|
return NS_OK;
|
|
}
|
|
|
|
/*
|
|
* nsIMutationObserver interface
|
|
*/
|
|
|
|
void NodeIterator::ContentRemoved(nsIDocument *aDocument,
|
|
nsIContent *aContainer,
|
|
nsIContent *aChild,
|
|
nsIContent *aPreviousSibling)
|
|
{
|
|
nsINode *container = NODE_FROM(aContainer, aDocument);
|
|
|
|
mPointer.AdjustAfterRemoval(mRoot, container, aChild, aPreviousSibling);
|
|
mWorkingPointer.AdjustAfterRemoval(mRoot, container, aChild, aPreviousSibling);
|
|
}
|
|
|
|
bool
|
|
NodeIterator::WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector)
|
|
{
|
|
return NodeIteratorBinding::Wrap(cx, this, aGivenProto, aReflector);
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|