void ShadowRoot::recalcStyle(StyleRecalcChange change)
{
// ShadowRoot doesn't support custom callbacks.
ASSERT(!hasCustomStyleCallbacks());
StyleResolverParentScope parentScope(*this);
if (styleChangeType() >= SubtreeStyleChange)
change = Force;
if (change < Force && hasRareData() && childNeedsStyleRecalc())
checkForChildrenAdjacentRuleChanges();
// There's no style to update so just calling recalcStyle means we're updated.
clearNeedsStyleRecalc();
// FIXME: This doesn't handle :hover + div properly like Element::recalcStyle does.
Text* lastTextNode = 0;
for (Node* child = lastChild(); child; child = child->previousSibling()) {
if (child->isTextNode()) {
toText(child)->recalcTextStyle(change, lastTextNode);
lastTextNode = toText(child);
} else if (child->isElementNode()) {
if (child->shouldCallRecalcStyle(change))
toElement(child)->recalcStyle(change, lastTextNode);
if (child->renderer())
lastTextNode = 0;
}
}
clearChildNeedsStyleRecalc();
}
void ShadowRoot::recalcStyle(StyleChange change)
{
if (hasContentElement())
forceReattach(this);
else {
for (Node* n = firstChild(); n; n = n->nextSibling())
n->recalcStyle(change);
}
clearNeedsStyleRecalc();
clearChildNeedsStyleRecalc();
}
void Text::recalcTextStyle(StyleRecalcChange change)
{
if (RenderText* renderer = this->renderer()) {
if (change != NoChange || needsStyleRecalc())
renderer->setStyle(document().styleResolver().styleForText(this));
if (needsStyleRecalc())
renderer->setText(dataImpl());
clearNeedsStyleRecalc();
} else if (needsStyleRecalc() || needsWhitespaceRenderer()) {
reattach();
}
}
void Text::recalcTextStyle(StyleRecalcChange change, Text* nextTextSibling)
{
if (LayoutTextItem layoutItem = LayoutTextItem(this->layoutObject())) {
if (change != NoChange || needsStyleRecalc())
layoutItem.setStyle(document().ensureStyleResolver().styleForText(this));
if (needsStyleRecalc())
layoutItem.setText(dataImpl());
clearNeedsStyleRecalc();
} else if (needsStyleRecalc() || needsWhitespaceLayoutObject()) {
reattach();
if (this->layoutObject())
reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
}
}
bool Text::recalcTextStyle(StyleChange change)
{
if (RenderText* renderer = toRenderText(this->renderer())) {
if (change != NoChange || needsStyleRecalc())
renderer->setStyle(document()->styleResolver()->styleForText(this));
if (needsStyleRecalc())
renderer->setText(dataImpl());
clearNeedsStyleRecalc();
} else if (needsStyleRecalc() || needsWhitespaceRenderer()) {
reattach();
return true;
}
return false;
}
void Text::recalcStyle(StyleChange change)
{
if (change != NoChange && parentNode()) {
if (renderer())
renderer()->setStyle(parentNode()->renderer()->style());
}
if (needsStyleRecalc()) {
if (renderer()) {
if (renderer()->isText())
toRenderText(renderer())->setText(dataImpl());
} else
reattach();
}
clearNeedsStyleRecalc();
}
void Text::recalcTextStyle(StyleChange change)
{
RenderText* renderer = toRenderText(this->renderer());
if (change != NoChange && renderer)
renderer->setStyle(document()->ensureStyleResolver()->styleForText(this));
if (needsStyleRecalc()) {
if (renderer)
renderer->setText(dataImpl());
else
reattach();
}
clearNeedsStyleRecalc();
}
void ShadowRoot::recalcShadowTreeStyle(StyleChange change)
{
if (hasContentElement())
reattach();
else {
for (Node* n = firstChild(); n; n = n->nextSibling()) {
if (n->isElementNode())
static_cast<Element*>(n)->recalcStyle(change);
else if (n->isTextNode())
static_cast<Text*>(n)->recalcTextStyle(change);
}
}
clearNeedsStyleRecalc();
clearChildNeedsStyleRecalc();
}
void ShadowRoot::recalcStyle(StyleRecalcChange change)
{
// ShadowRoot doesn't support custom callbacks.
ASSERT(!hasCustomStyleCallbacks());
StyleResolverParentScope parentScope(*this);
if (styleChangeType() >= SubtreeStyleChange)
change = Force;
// There's no style to update so just calling recalcStyle means we're updated.
clearNeedsStyleRecalc();
recalcChildStyle(change);
clearChildNeedsStyleRecalc();
}
void ShadowRoot::recalcStyle(StyleRecalcChange change) {
// ShadowRoot doesn't support custom callbacks.
DCHECK(!hasCustomStyleCallbacks());
StyleSharingDepthScope sharingScope(*this);
if (getStyleChangeType() >= SubtreeStyleChange)
change = Force;
// There's no style to update so just calling recalcStyle means we're updated.
clearNeedsStyleRecalc();
clearNeedsReattachLayoutTree();
recalcDescendantStyles(change);
clearChildNeedsStyleRecalc();
clearChildNeedsReattachLayoutTree();
}
void Text::recalcTextStyle(StyleChange change)
{
if (hasCustomCallbacks())
willRecalcTextStyle(change);
if (change != NoChange && parentNode() && parentNode()->renderer()) {
if (renderer())
renderer()->setStyle(parentNode()->renderer()->style());
}
if (needsStyleRecalc()) {
if (renderer()) {
if (renderer()->isText())
toRenderText(renderer())->setText(dataImpl());
} else
reattach();
}
clearNeedsStyleRecalc();
}
void ShadowRoot::recalcStyle(StyleChange change)
{
// ShadowRoot doesn't support custom callbacks.
ASSERT(!hasCustomCallbacks());
StyleResolver* styleResolver = document()->styleResolver();
styleResolver->pushParentShadowRoot(this);
for (Node* child = firstChild(); child; child = child->nextSibling()) {
if (child->isElementNode())
static_cast<Element*>(child)->recalcStyle(change);
else if (child->isTextNode())
toText(child)->recalcTextStyle(change);
}
styleResolver->popParentShadowRoot(this);
clearNeedsStyleRecalc();
clearChildNeedsStyleRecalc();
}
void ShadowRoot::recalcStyle(StyleRecalcChange change)
{
if (styleChangeType() >= SubtreeStyleChange)
change = Force;
// There's no style to update so just calling recalcStyle means we're updated.
clearNeedsStyleRecalc();
for (Node* child = lastChild(); child; child = child->previousSibling()) {
if (child->isTextNode()) {
toText(child)->recalcTextStyle(change);
} else if (child->isElementNode()) {
if (child->shouldCallRecalcStyle(change))
toElement(child)->recalcStyle(change);
}
}
clearChildNeedsStyleRecalc();
}
void Text::recalcTextStyle(StyleChange change)
{
if (hasCustomCallbacks())
willRecalcTextStyle(change);
RenderObject* renderer = this->renderer();
// The only time we have a renderer and our parent doesn't is if our parent
// is a shadow root.
if (change != NoChange && renderer && !parentNode()->isShadowRoot())
renderer->setStyle(parentNode()->renderer()->style());
if (needsStyleRecalc()) {
if (renderer) {
if (renderer->isText())
toRenderText(renderer)->setText(dataImpl());
} else
reattach();
}
clearNeedsStyleRecalc();
}
void Element::recalcStyle(StyleRecalcChange change)
{
ASSERT(document().inStyleRecalc());
ASSERT(!parentNode()->needsStyleRecalc());
if (change >= Inherit || needsStyleRecalc()) {
if (hasRareData()) {
ElementRareData* data = elementRareData();
data->clearComputedStyle();
}
if (parentRenderStyle())
change = recalcOwnStyle(change);
clearNeedsStyleRecalc();
}
// If we reattached we don't need to recalc the style of our descendants anymore.
if ((change >= Inherit && change < Reattach) || childNeedsStyleRecalc()) {
recalcChildStyle(change);
clearChildNeedsStyleRecalc();
}
}
