6d25ae0f09
Most of these elements are simple to support. One slightly tricky item was <input type=date>, as testing indicates that the front-end code usually (consistently?) hides the picker using setPickerState(), which does not end up calling closeDateTimePicker() as might be expected. So to properly track the open/closed state, I had to add a SetDateTimePickerState webidl method, rather than just patching into the existing Open/Close calls. Differential Revision: https://phabricator.services.mozilla.com/D234093
368 lines
11 KiB
C++
368 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/dom/HTMLDialogElement.h"
|
|
#include "mozilla/dom/ElementBinding.h"
|
|
#include "mozilla/dom/CloseWatcher.h"
|
|
#include "mozilla/dom/CloseWatcherManager.h"
|
|
#include "mozilla/dom/HTMLDialogElementBinding.h"
|
|
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsFocusManager.h"
|
|
#include "nsIFrame.h"
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT(Dialog)
|
|
|
|
namespace mozilla::dom {
|
|
|
|
HTMLDialogElement::~HTMLDialogElement() = default;
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLDialogElement)
|
|
|
|
class DialogCloseWatcherListener : public nsIDOMEventListener {
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
explicit DialogCloseWatcherListener(HTMLDialogElement* aDialog) {
|
|
mDialog = do_GetWeakReference(aDialog);
|
|
}
|
|
|
|
NS_IMETHODIMP HandleEvent(Event* aEvent) override {
|
|
RefPtr<nsINode> node = do_QueryReferent(mDialog);
|
|
if (HTMLDialogElement* dialog = HTMLDialogElement::FromNodeOrNull(node)) {
|
|
nsAutoString eventType;
|
|
aEvent->GetType(eventType);
|
|
if (eventType.EqualsLiteral("cancel")) {
|
|
bool defaultAction = true;
|
|
auto cancelable =
|
|
aEvent->Cancelable() ? Cancelable::eYes : Cancelable::eNo;
|
|
nsContentUtils::DispatchTrustedEvent(dialog->OwnerDoc(), dialog,
|
|
u"cancel"_ns, CanBubble::eNo,
|
|
cancelable, &defaultAction);
|
|
if (!defaultAction) {
|
|
aEvent->PreventDefault();
|
|
}
|
|
} else if (eventType.EqualsLiteral("close")) {
|
|
Optional<nsAString> retValue;
|
|
dialog->Close(retValue);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
virtual ~DialogCloseWatcherListener() = default;
|
|
nsWeakPtr mDialog;
|
|
};
|
|
NS_IMPL_ISUPPORTS(DialogCloseWatcherListener, nsIDOMEventListener)
|
|
|
|
void HTMLDialogElement::Close(
|
|
const mozilla::dom::Optional<nsAString>& aReturnValue) {
|
|
if (!Open()) {
|
|
return;
|
|
}
|
|
|
|
if (StaticPrefs::dom_element_dialog_toggle_events_enabled()) {
|
|
FireToggleEvent(u"open"_ns, u"closed"_ns, u"beforetoggle"_ns);
|
|
if (!Open()) {
|
|
return;
|
|
}
|
|
QueueToggleEventTask();
|
|
}
|
|
|
|
if (aReturnValue.WasPassed()) {
|
|
SetReturnValue(aReturnValue.Value());
|
|
}
|
|
|
|
SetOpen(false, IgnoreErrors());
|
|
|
|
RemoveFromTopLayerIfNeeded();
|
|
|
|
RefPtr<Element> previouslyFocusedElement =
|
|
do_QueryReferent(mPreviouslyFocusedElement);
|
|
|
|
if (previouslyFocusedElement) {
|
|
mPreviouslyFocusedElement = nullptr;
|
|
|
|
FocusOptions options;
|
|
options.mPreventScroll = true;
|
|
previouslyFocusedElement->Focus(options, CallerType::NonSystem,
|
|
IgnoredErrorResult());
|
|
}
|
|
|
|
RefPtr<AsyncEventDispatcher> eventDispatcher =
|
|
new AsyncEventDispatcher(this, u"close"_ns, CanBubble::eNo);
|
|
eventDispatcher->PostDOMEvent();
|
|
|
|
if (mCloseWatcher) {
|
|
mCloseWatcher->Destroy();
|
|
mCloseWatcher = nullptr;
|
|
}
|
|
}
|
|
|
|
void HTMLDialogElement::Show(ErrorResult& aError) {
|
|
if (Open()) {
|
|
if (!IsInTopLayer()) {
|
|
return;
|
|
}
|
|
return aError.ThrowInvalidStateError(
|
|
"Cannot call show() on an open modal dialog.");
|
|
}
|
|
|
|
if (StaticPrefs::dom_element_dialog_toggle_events_enabled()) {
|
|
if (FireToggleEvent(u"closed"_ns, u"open"_ns, u"beforetoggle"_ns)) {
|
|
return;
|
|
}
|
|
if (Open()) {
|
|
return;
|
|
}
|
|
QueueToggleEventTask();
|
|
}
|
|
|
|
SetOpen(true, IgnoreErrors());
|
|
|
|
StorePreviouslyFocusedElement();
|
|
|
|
RefPtr<nsINode> hideUntil = GetTopmostPopoverAncestor(nullptr, false);
|
|
if (!hideUntil) {
|
|
hideUntil = OwnerDoc();
|
|
}
|
|
|
|
OwnerDoc()->HideAllPopoversUntil(*hideUntil, false, true);
|
|
FocusDialog();
|
|
}
|
|
|
|
bool HTMLDialogElement::IsInTopLayer() const {
|
|
return State().HasState(ElementState::MODAL);
|
|
}
|
|
|
|
void HTMLDialogElement::AddToTopLayerIfNeeded() {
|
|
MOZ_ASSERT(IsInComposedDoc());
|
|
if (IsInTopLayer()) {
|
|
return;
|
|
}
|
|
|
|
OwnerDoc()->AddModalDialog(*this);
|
|
}
|
|
|
|
void HTMLDialogElement::RemoveFromTopLayerIfNeeded() {
|
|
if (!IsInTopLayer()) {
|
|
return;
|
|
}
|
|
OwnerDoc()->RemoveModalDialog(*this);
|
|
}
|
|
|
|
void HTMLDialogElement::StorePreviouslyFocusedElement() {
|
|
if (Element* element = nsFocusManager::GetFocusedElementStatic()) {
|
|
if (NS_SUCCEEDED(nsContentUtils::CheckSameOrigin(this, element))) {
|
|
mPreviouslyFocusedElement = do_GetWeakReference(element);
|
|
}
|
|
} else if (Document* doc = GetComposedDoc()) {
|
|
// Looks like there's a discrepancy sometimes when focus is moved
|
|
// to a different in-process window.
|
|
if (nsIContent* unretargetedFocus = doc->GetUnretargetedFocusedContent()) {
|
|
mPreviouslyFocusedElement = do_GetWeakReference(unretargetedFocus);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HTMLDialogElement::UnbindFromTree(UnbindContext& aContext) {
|
|
RemoveFromTopLayerIfNeeded();
|
|
|
|
if (mCloseWatcher) {
|
|
mCloseWatcher->Destroy();
|
|
mCloseWatcher = nullptr;
|
|
}
|
|
|
|
nsGenericHTMLElement::UnbindFromTree(aContext);
|
|
}
|
|
|
|
void HTMLDialogElement::ShowModal(ErrorResult& aError) {
|
|
if (Open()) {
|
|
if (IsInTopLayer()) {
|
|
return;
|
|
}
|
|
return aError.ThrowInvalidStateError(
|
|
"Cannot call showModal() on an open non-modal dialog.");
|
|
}
|
|
|
|
if (!IsInComposedDoc()) {
|
|
return aError.ThrowInvalidStateError("Dialog element is not connected");
|
|
}
|
|
|
|
if (IsPopoverOpen()) {
|
|
return aError.ThrowInvalidStateError(
|
|
"Dialog element is already an open popover.");
|
|
}
|
|
|
|
if (StaticPrefs::dom_element_dialog_toggle_events_enabled()) {
|
|
if (FireToggleEvent(u"closed"_ns, u"open"_ns, u"beforetoggle"_ns)) {
|
|
return;
|
|
}
|
|
if (Open() || !IsInComposedDoc() || IsPopoverOpen()) {
|
|
return;
|
|
}
|
|
QueueToggleEventTask();
|
|
}
|
|
|
|
AddToTopLayerIfNeeded();
|
|
|
|
SetOpen(true, aError);
|
|
|
|
StorePreviouslyFocusedElement();
|
|
|
|
if (StaticPrefs::dom_closewatcher_enabled()) {
|
|
RefPtr<Document> doc = OwnerDoc();
|
|
if (doc->IsActive() && doc->IsCurrentActiveDocument()) {
|
|
if (RefPtr window = OwnerDoc()->GetInnerWindow()) {
|
|
mCloseWatcher = new CloseWatcher(window);
|
|
RefPtr<DialogCloseWatcherListener> eventListener =
|
|
new DialogCloseWatcherListener(this);
|
|
mCloseWatcher->AddSystemEventListener(u"cancel"_ns, eventListener,
|
|
false /* aUseCapture */,
|
|
false /* aWantsUntrusted */);
|
|
mCloseWatcher->AddSystemEventListener(u"close"_ns, eventListener,
|
|
false /* aUseCapture */,
|
|
false /* aWantsUntrusted */);
|
|
window->EnsureCloseWatcherManager()->Add(*mCloseWatcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
RefPtr<nsINode> hideUntil = GetTopmostPopoverAncestor(nullptr, false);
|
|
if (!hideUntil) {
|
|
hideUntil = OwnerDoc();
|
|
}
|
|
|
|
OwnerDoc()->HideAllPopoversUntil(*hideUntil, false, true);
|
|
FocusDialog();
|
|
|
|
aError.SuppressException();
|
|
}
|
|
|
|
void HTMLDialogElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
bool aNotify) {
|
|
nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue, aOldValue,
|
|
aMaybeScriptedPrincipal, aNotify);
|
|
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::open) {
|
|
MOZ_ASSERT(Open() == !!aValue);
|
|
SetStates(ElementState::OPEN, !!aValue);
|
|
}
|
|
}
|
|
|
|
void HTMLDialogElement::AsyncEventRunning(AsyncEventDispatcher* aEvent) {
|
|
if (mToggleEventDispatcher == aEvent) {
|
|
mToggleEventDispatcher = nullptr;
|
|
}
|
|
}
|
|
|
|
void HTMLDialogElement::FocusDialog() {
|
|
// 1) If subject is inert, return.
|
|
// 2) Let control be the first descendant element of subject, in tree
|
|
// order, that is not inert and has the autofocus attribute specified.
|
|
RefPtr<Document> doc = OwnerDoc();
|
|
if (IsInComposedDoc()) {
|
|
doc->FlushPendingNotifications(FlushType::Frames);
|
|
}
|
|
|
|
RefPtr<Element> control = HasAttr(nsGkAtoms::autofocus)
|
|
? this
|
|
: GetFocusDelegate(IsFocusableFlags(0));
|
|
|
|
// If there isn't one of those either, then let control be subject.
|
|
if (!control) {
|
|
control = this;
|
|
}
|
|
|
|
FocusCandidate(control, IsInTopLayer());
|
|
}
|
|
|
|
int32_t HTMLDialogElement::TabIndexDefault() { return 0; }
|
|
|
|
void HTMLDialogElement::QueueCancelDialog() {
|
|
// queues an element task on the user interaction task source
|
|
OwnerDoc()->Dispatch(
|
|
NewRunnableMethod("HTMLDialogElement::RunCancelDialogSteps", this,
|
|
&HTMLDialogElement::RunCancelDialogSteps));
|
|
}
|
|
|
|
void HTMLDialogElement::RunCancelDialogSteps() {
|
|
// 1) Let close be the result of firing an event named cancel at dialog, with
|
|
// the cancelable attribute initialized to true.
|
|
bool defaultAction = true;
|
|
nsContentUtils::DispatchTrustedEvent(OwnerDoc(), this, u"cancel"_ns,
|
|
CanBubble::eNo, Cancelable::eYes,
|
|
&defaultAction);
|
|
|
|
// 2) If close is true and dialog has an open attribute, then close the dialog
|
|
// with no return value.
|
|
if (defaultAction) {
|
|
Optional<nsAString> retValue;
|
|
Close(retValue);
|
|
}
|
|
}
|
|
|
|
bool HTMLDialogElement::IsValidInvokeAction(InvokeAction aAction) const {
|
|
return nsGenericHTMLElement::IsValidInvokeAction(aAction) ||
|
|
aAction == InvokeAction::ShowModal || aAction == InvokeAction::Close;
|
|
}
|
|
|
|
bool HTMLDialogElement::HandleInvokeInternal(Element* aInvoker,
|
|
InvokeAction aAction,
|
|
ErrorResult& aRv) {
|
|
if (nsGenericHTMLElement::HandleInvokeInternal(aInvoker, aAction, aRv)) {
|
|
return true;
|
|
}
|
|
|
|
MOZ_ASSERT(IsValidInvokeAction(aAction));
|
|
|
|
const bool actionMayClose =
|
|
aAction == InvokeAction::Auto || aAction == InvokeAction::Close;
|
|
const bool actionMayOpen =
|
|
aAction == InvokeAction::Auto || aAction == InvokeAction::ShowModal;
|
|
|
|
if (actionMayClose && Open()) {
|
|
Optional<nsAString> retValue;
|
|
Close(retValue);
|
|
return true;
|
|
}
|
|
|
|
if (IsInComposedDoc() && !Open() && actionMayOpen) {
|
|
ShowModal(aRv);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HTMLDialogElement::QueueToggleEventTask() {
|
|
nsAutoString oldState;
|
|
auto newState = Open() ? u"closed"_ns : u"open"_ns;
|
|
if (mToggleEventDispatcher) {
|
|
oldState.Truncate();
|
|
static_cast<ToggleEvent*>(mToggleEventDispatcher->mEvent.get())
|
|
->GetOldState(oldState);
|
|
mToggleEventDispatcher->Cancel();
|
|
} else {
|
|
oldState.Assign(Open() ? u"open"_ns : u"closed"_ns);
|
|
}
|
|
RefPtr<ToggleEvent> toggleEvent =
|
|
CreateToggleEvent(u"toggle"_ns, oldState, newState, Cancelable::eNo);
|
|
mToggleEventDispatcher = new AsyncEventDispatcher(this, toggleEvent.forget());
|
|
mToggleEventDispatcher->PostDOMEvent();
|
|
}
|
|
|
|
JSObject* HTMLDialogElement::WrapNode(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return HTMLDialogElement_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
} // namespace mozilla::dom
|