HTMLDetailsElement.cpp [plain text]
#include "config.h"
#include "HTMLDetailsElement.h"
#include "AXObjectCache.h"
#include "ElementIterator.h"
#include "EventNames.h"
#include "EventSender.h"
#include "HTMLSlotElement.h"
#include "HTMLSummaryElement.h"
#include "LocalizedStrings.h"
#include "MouseEvent.h"
#include "RenderBlockFlow.h"
#include "ShadowRoot.h"
#include "SlotAssignment.h"
#include "Text.h"
#include <wtf/IsoMallocInlines.h>
#include <wtf/NeverDestroyed.h>
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(HTMLDetailsElement);
using namespace HTMLNames;
static DetailEventSender& detailToggleEventSender()
{
static NeverDestroyed<DetailEventSender> sharedToggleEventSender(eventNames().toggleEvent);
return sharedToggleEventSender;
}
static const AtomString& summarySlotName()
{
static MainThreadNeverDestroyed<const AtomString> summarySlot("summarySlot");
return summarySlot;
}
class DetailsSlotAssignment final : public SlotAssignment {
private:
void hostChildElementDidChange(const Element&, ShadowRoot&) override;
const AtomString& slotNameForHostChild(const Node&) const override;
};
void DetailsSlotAssignment::hostChildElementDidChange(const Element& childElement, ShadowRoot& shadowRoot)
{
if (is<HTMLSummaryElement>(childElement)) {
didChangeSlot(summarySlotName(), shadowRoot);
} else
didChangeSlot(SlotAssignment::defaultSlotName(), shadowRoot);
}
const AtomString& DetailsSlotAssignment::slotNameForHostChild(const Node& child) const
{
auto& parent = *child.parentNode();
ASSERT(is<HTMLDetailsElement>(parent));
auto& details = downcast<HTMLDetailsElement>(parent);
if (is<HTMLSummaryElement>(child)) {
if (&child == childrenOfType<HTMLSummaryElement>(details).first())
return summarySlotName();
}
return SlotAssignment::defaultSlotName();
}
Ref<HTMLDetailsElement> HTMLDetailsElement::create(const QualifiedName& tagName, Document& document)
{
auto details = adoptRef(*new HTMLDetailsElement(tagName, document));
details->addShadowRoot(ShadowRoot::create(document, makeUnique<DetailsSlotAssignment>()));
return details;
}
HTMLDetailsElement::HTMLDetailsElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
{
ASSERT(hasTagName(detailsTag));
}
HTMLDetailsElement::~HTMLDetailsElement()
{
detailToggleEventSender().cancelEvent(*this);
}
RenderPtr<RenderElement> HTMLDetailsElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
{
return createRenderer<RenderBlockFlow>(*this, WTFMove(style));
}
void HTMLDetailsElement::didAddUserAgentShadowRoot(ShadowRoot& root)
{
auto summarySlot = HTMLSlotElement::create(slotTag, document());
summarySlot->setAttributeWithoutSynchronization(nameAttr, summarySlotName());
m_summarySlot = summarySlot.ptr();
auto defaultSummary = HTMLSummaryElement::create(summaryTag, document());
defaultSummary->appendChild(Text::create(document(), defaultDetailsSummaryText()));
m_defaultSummary = defaultSummary.ptr();
summarySlot->appendChild(defaultSummary);
root.appendChild(summarySlot);
m_defaultSlot = HTMLSlotElement::create(slotTag, document());
ASSERT(!m_isOpen);
}
bool HTMLDetailsElement::isActiveSummary(const HTMLSummaryElement& summary) const
{
if (!m_summarySlot->assignedNodes())
return &summary == m_defaultSummary;
if (summary.parentNode() != this)
return false;
auto slot = makeRefPtr(shadowRoot()->findAssignedSlot(summary));
if (!slot)
return false;
return slot == m_summarySlot;
}
void HTMLDetailsElement::dispatchPendingEvent(DetailEventSender* eventSender)
{
ASSERT_UNUSED(eventSender, eventSender == &detailToggleEventSender());
dispatchEvent(Event::create(eventNames().toggleEvent, Event::CanBubble::No, Event::IsCancelable::No));
}
void HTMLDetailsElement::parseAttribute(const QualifiedName& name, const AtomString& value)
{
if (name == openAttr) {
bool oldValue = m_isOpen;
m_isOpen = !value.isNull();
if (oldValue != m_isOpen) {
auto root = makeRefPtr(shadowRoot());
ASSERT(root);
if (m_isOpen)
root->appendChild(*m_defaultSlot);
else
root->removeChild(*m_defaultSlot);
detailToggleEventSender().cancelEvent(*this);
detailToggleEventSender().dispatchEventSoon(*this);
}
} else
HTMLElement::parseAttribute(name, value);
}
void HTMLDetailsElement::toggleOpen()
{
setAttributeWithoutSynchronization(openAttr, m_isOpen ? nullAtom() : emptyAtom());
if (AXObjectCache* cache = document().existingAXObjectCache())
cache->postNotification(nullptr, &document(), AXObjectCache::AXExpandedChanged);
}
}