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::InsertionNotificationRequest HTMLSlotElement::insertedInto(ContainerNode& insertionPoint)
{
auto insertionResult = HTMLElement::insertedInto(insertionPoint);
ASSERT_UNUSED(insertionResult, insertionResult == InsertionDone);
if (insertionPoint.isInShadowTree() && isInShadowTree() && &insertionPoint.treeScope() == &treeScope()) {
if (auto shadowRoot = containingShadowRoot())
shadowRoot->addSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
return InsertionDone;
}
void HTMLSlotElement::removedFrom(ContainerNode& insertionPoint)
{
if (insertionPoint.isInShadowTree() && isInShadowTree() && &treeScope() == &document()) {
auto* oldShadowRoot = insertionPoint.containingShadowRoot();
ASSERT(oldShadowRoot);
oldShadowRoot->removeSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
HTMLElement::removedFrom(insertionPoint);
}
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 = containingShadowRoot()) {
shadowRoot->removeSlotElementByName(oldValue, *this);
shadowRoot->addSlotElementByName(newValue, *this);
}
}
}
const Vector<Node*>* HTMLSlotElement::assignedNodes() const
{
auto* shadowRoot = 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 (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);
}
return;
}
for (Node* node : *assignedNodes) {
if (is<HTMLSlotElement>(*node))
flattenAssignedNodes(nodes, downcast<HTMLSlotElement>(*node));
else
nodes.append(node);
}
}
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);
}
}