InsertionPoint.cpp [plain text]
#include "config.h"
#include "InsertionPoint.h"
#include "ElementShadow.h"
#include "HTMLNames.h"
#include "QualifiedName.h"
#include "ShadowRoot.h"
#include "StaticNodeList.h"
namespace WebCore {
using namespace HTMLNames;
InsertionPoint::InsertionPoint(const QualifiedName& tagName, Document* document)
: HTMLElement(tagName, document, CreateInsertionPoint)
, m_hasDistribution(false)
{
}
InsertionPoint::~InsertionPoint()
{
}
void InsertionPoint::attach(const AttachContext& context)
{
if (ShadowRoot* shadowRoot = containingShadowRoot())
ContentDistributor::ensureDistribution(shadowRoot);
for (Node* current = firstDistributed(); current; current = nextDistributedTo(current)) {
if (!current->attached())
current->attach(context);
}
HTMLElement::attach(context);
}
void InsertionPoint::detach(const AttachContext& context)
{
if (ShadowRoot* shadowRoot = containingShadowRoot())
ContentDistributor::ensureDistribution(shadowRoot);
for (Node* current = firstDistributed(); current; current = nextDistributedTo(current))
current->detach(context);
HTMLElement::detach(context);
}
bool InsertionPoint::shouldUseFallbackElements() const
{
return isActive() && !hasDistribution();
}
bool InsertionPoint::isShadowBoundary() const
{
return treeScope()->rootNode()->isShadowRoot() && isActive();
}
bool InsertionPoint::isActive() const
{
if (!containingShadowRoot())
return false;
const Node* node = parentNode();
while (node) {
if (node->isInsertionPoint())
return false;
node = node->parentNode();
}
return true;
}
bool InsertionPoint::rendererIsNeeded(const NodeRenderingContext& context)
{
return !isShadowBoundary() && HTMLElement::rendererIsNeeded(context);
}
void InsertionPoint::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
{
HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
if (ShadowRoot* root = containingShadowRoot())
if (ElementShadow* rootOwner = root->owner())
rootOwner->invalidateDistribution();
}
Node::InsertionNotificationRequest InsertionPoint::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (ShadowRoot* root = containingShadowRoot()) {
if (ElementShadow* rootOwner = root->owner()) {
rootOwner->distributor().didShadowBoundaryChange(root->host());
rootOwner->distributor().invalidateInsertionPointList();
}
}
return InsertionDone;
}
void InsertionPoint::removedFrom(ContainerNode* insertionPoint)
{
ShadowRoot* root = containingShadowRoot();
if (!root)
root = insertionPoint->containingShadowRoot();
ElementShadow* rootOwner = root ? root->owner() : 0;
if (rootOwner) {
rootOwner->invalidateDistribution();
rootOwner->distributor().invalidateInsertionPointList();
}
clearDistribution();
HTMLElement::removedFrom(insertionPoint);
}
void InsertionPoint::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == reset_style_inheritanceAttr) {
if (!inDocument() || !attached() || !isActive())
return;
containingShadowRoot()->host()->setNeedsStyleRecalc();
} else
HTMLElement::parseAttribute(name, value);
}
bool InsertionPoint::resetStyleInheritance() const
{
return fastHasAttribute(reset_style_inheritanceAttr);
}
void InsertionPoint::setResetStyleInheritance(bool value)
{
setBooleanAttribute(reset_style_inheritanceAttr, value);
}
Node* InsertionPoint::firstDistributed() const
{
if (!m_hasDistribution)
return 0;
for (Node* current = shadowHost()->firstChild(); current; current = current->nextSibling()) {
if (matchTypeFor(current) == InsertionPoint::AlwaysMatches)
return current;
}
return 0;
}
Node* InsertionPoint::lastDistributed() const
{
if (!m_hasDistribution)
return 0;
for (Node* current = shadowHost()->lastChild(); current; current = current->previousSibling()) {
if (matchTypeFor(current) == InsertionPoint::AlwaysMatches)
return current;
}
return 0;
}
Node* InsertionPoint::nextDistributedTo(const Node* node) const
{
for (Node* current = node->nextSibling(); current; current = current->nextSibling()) {
if (matchTypeFor(current) == InsertionPoint::AlwaysMatches)
return current;
}
return 0;
}
Node* InsertionPoint::previousDistributedTo(const Node* node) const
{
for (Node* current = node->previousSibling(); current; current = current->previousSibling()) {
if (matchTypeFor(current) == InsertionPoint::AlwaysMatches)
return current;
}
return 0;
}
InsertionPoint* resolveReprojection(const Node* projectedNode)
{
if (ElementShadow* shadow = shadowOfParentForDistribution(projectedNode)) {
if (ShadowRoot* root = projectedNode->containingShadowRoot())
ContentDistributor::ensureDistribution(root);
return shadow->distributor().findInsertionPointFor(projectedNode);
}
return 0;
}
}