HTMLSlotElement.cpp [plain text]
#include "config.h"
#include "HTMLSlotElement.h"
#include "Event.h"
#include "EventNames.h"
#include "HTMLNames.h"
#include "MutationObserver.h"
#include "ShadowRoot.h"
#include "Text.h"
namespace WebCore {
using namespace HTMLNames;
Ref<HTMLSlotElement> HTMLSlotElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(*new HTMLSlotElement(tagName, document));
}
HTMLSlotElement::HTMLSlotElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
{
ASSERT(hasTagName(slotTag));
}
HTMLSlotElement::InsertedIntoAncestorResult HTMLSlotElement::insertedIntoAncestor(InsertionType insertionType, ContainerNode& parentOfInsertedTree)
{
auto insertionResult = HTMLElement::insertedIntoAncestor(insertionType, parentOfInsertedTree);
ASSERT_UNUSED(insertionResult, insertionResult == InsertedIntoAncestorResult::Done);
if (insertionType.treeScopeChanged && isInShadowTree()) {
if (auto shadowRoot = containingShadowRoot())
shadowRoot->addSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
return InsertedIntoAncestorResult::Done;
}
void HTMLSlotElement::removedFromAncestor(RemovalType removalType, ContainerNode& oldParentOfRemovedTree)
{
if (removalType.treeScopeChanged && oldParentOfRemovedTree.isInShadowTree()) {
auto* oldShadowRoot = oldParentOfRemovedTree.containingShadowRoot();
ASSERT(oldShadowRoot);
oldShadowRoot->removeSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
HTMLElement::removedFromAncestor(removalType, oldParentOfRemovedTree);
}
void HTMLSlotElement::attributeChanged(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue, AttributeModificationReason reason)
{
HTMLElement::attributeChanged(name, oldValue, newValue, reason);
if (isInShadowTree() && name == nameAttr) {
if (auto shadowRoot = makeRefPtr(containingShadowRoot())) {
shadowRoot->removeSlotElementByName(oldValue, *this);
shadowRoot->addSlotElementByName(newValue, *this);
}
}
}
const Vector<Node*>* HTMLSlotElement::assignedNodes() const
{
auto shadowRoot = makeRefPtr(containingShadowRoot());
if (!shadowRoot)
return nullptr;
return shadowRoot->assignedNodesForSlot(*this);
}
static void flattenAssignedNodes(Vector<Node*>& nodes, const HTMLSlotElement& slot)
{
auto* assignedNodes = slot.assignedNodes();
if (!assignedNodes) {
for (RefPtr<Node> child = slot.firstChild(); child; child = child->nextSibling()) {
if (is<HTMLSlotElement>(*child))
flattenAssignedNodes(nodes, downcast<HTMLSlotElement>(*child));
else if (is<Text>(*child) || is<Element>(*child))
nodes.append(child.get());
}
return;
}
for (RefPtr<Node> node : *assignedNodes) {
if (is<HTMLSlotElement>(*node))
flattenAssignedNodes(nodes, downcast<HTMLSlotElement>(*node));
else
nodes.append(node.get());
}
}
Vector<Node*> HTMLSlotElement::assignedNodes(const AssignedNodesOptions& options) const
{
if (options.flatten) {
Vector<Node*> nodes;
flattenAssignedNodes(nodes, *this);
return nodes;
}
auto* assignedNodes = this->assignedNodes();
if (!assignedNodes)
return { };
return *assignedNodes;
}
void HTMLSlotElement::enqueueSlotChangeEvent()
{
if (m_inSignalSlotList)
return;
m_inSignalSlotList = true;
MutationObserver::enqueueSlotChangeEvent(*this);
}
void HTMLSlotElement::dispatchSlotChangeEvent()
{
m_inSignalSlotList = false;
bool bubbles = true;
bool cancelable = false;
Ref<Event> event = Event::create(eventNames().slotchangeEvent, bubbles, cancelable);
event->setTarget(this);
dispatchEvent(event);
}
}