Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "nsMenuItemX.h"
#include "mozilla/dom/HTMLImageElement.h"
#include "nsMenuBarX.h"
#include "nsMenuX.h"
#include "nsMenuItemIconX.h"
#include "nsMenuUtilsX.h"
#include "nsCocoaUtils.h"
#include "nsObjCExceptions.h"
#include "nsCOMPtr.h"
#include "nsGkAtoms.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h"
#include "mozilla/ErrorResult.h"
#include "nsIWidget.h"
#include "mozilla/dom/Document.h"
using namespace mozilla;
using mozilla::dom::CallerType;
using mozilla::dom::Event;
nsMenuItemX::nsMenuItemX(nsMenuX* aParent, const nsString& aLabel,
EMenuItemType aItemType,
nsMenuGroupOwnerX* aMenuGroupOwner, nsIContent* aNode)
: mContent(aNode),
mType(aItemType),
mMenuParent(aParent),
mMenuGroupOwner(aMenuGroupOwner) {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
MOZ_COUNT_CTOR(nsMenuItemX);
MOZ_RELEASE_ASSERT(mContent->IsElement(),
"nsMenuItemX should only be created for elements");
NS_ASSERTION(mMenuGroupOwner, "No menu owner given, must have one!");
mMenuGroupOwner->RegisterForContentChanges(mContent, this);
// if we have a command associated with this menu item, register for changes
// to the command DOM node
if (dom::Document* doc = mContent->GetUncomposedDoc()) {
nsAutoString ourCommand;
mContent->AsElement()->GetAttr(nsGkAtoms::command, ourCommand);
if (!ourCommand.IsEmpty()) {
dom::Element* commandElement = doc->GetElementById(ourCommand);
if (commandElement) {
mCommandElement = commandElement;
// register to observe the command DOM element
mMenuGroupOwner->RegisterForContentChanges(mCommandElement, this);
}
}
}
if (auto* img = dom::HTMLImageElement::FromNodeOrNull(
mContent->GetFirstElementChild())) {
mImageElement = img;
mMenuGroupOwner->RegisterForContentChanges(mImageElement, this);
}
// set up the native menu item
if (mType == eSeparatorMenuItemType) {
mNativeMenuItem = [[NSMenuItem separatorItem] retain];
} else {
NSString* newCocoaLabelString =
nsMenuUtilsX::GetTruncatedCocoaLabel(aLabel);
mNativeMenuItem = [[GeckoNSMenuItem alloc] initWithTitle:newCocoaLabelString
action:nil
keyEquivalent:@""];
SetEnabled();
SetChecked();
SetKeyEquiv();
SetBadge();
SetAttributedTitle();
SetIndentationLevel();
SetTooltip();
}
mIcon = MakeUnique<nsMenuItemIconX>(this);
mIsVisible = !nsMenuUtilsX::NodeIsHiddenOrCollapsed(mContent);
// Separators don't need actions, targets, or command registration.
if (mType != eSeparatorMenuItemType) {
// All menu items other than the "Copy" menu item share the same target and
// action, and are differentiated be a unique (representedObject, tag) pair.
// The "Copy" menu item is a special case that requires a macOS-default
// action of `copy:` and a default target in order for the "Edit" menu to be
// populated with OS-provided menu items such as the Emoji picker,
// especially in multi-language environments (see bug 1478347). Our
// application delegate implements `copy:` by simply forwarding it to
// [nsMenuBarX::sNativeEventTarget menuItemHit:].
if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::id,
u"menu_copy"_ns, eCaseMatters)) {
mNativeMenuItem.action = @selector(copy:);
} else {
mNativeMenuItem.action = @selector(menuItemHit:);
mNativeMenuItem.target = nsMenuBarX::sNativeEventTarget;
}
mNativeMenuItem.representedObject = mMenuGroupOwner->GetRepresentedObject();
mNativeMenuItem.tag = mMenuGroupOwner->RegisterForCommand(this);
}
if (mIsVisible) {
SetupIcon();
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
nsMenuItemX::~nsMenuItemX() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
// autorelease the native menu item so that anything else happening to this
// object happens before the native menu item actually dies
[mNativeMenuItem autorelease];
DetachFromGroupOwner();
MOZ_COUNT_DTOR(nsMenuItemX);
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::DetachFromGroupOwner() {
if (mMenuGroupOwner) {
mMenuGroupOwner->UnregisterCommand(mNativeMenuItem.tag);
if (mContent) {
mMenuGroupOwner->UnregisterForContentChanges(mContent);
}
if (mCommandElement) {
mMenuGroupOwner->UnregisterForContentChanges(mCommandElement);
}
if (mImageElement) {
mMenuGroupOwner->UnregisterForContentChanges(mImageElement);
}
}
mMenuGroupOwner = nullptr;
}
nsresult nsMenuItemX::ModifyChecked(bool aIsChecked) {
// update the content model. This will also handle unchecking our siblings
// if we are a radiomenu
mContent->AsElement()->SetBoolAttr(nsGkAtoms::checked, aIsChecked);
// update native menu item
SetChecked();
return NS_OK;
}
EMenuItemType nsMenuItemX::GetMenuItemType() { return mType; }
// Executes the "cached" javaScript command.
// Returns NS_OK if the command was executed properly, otherwise an error code.
void nsMenuItemX::DoCommand(NSEventModifierFlags aModifierFlags,
int16_t aButton) {
// flip "checked" state if we're a checkbox menu, or an un-checked radio menu
if (mType == eCheckboxMenuItemType ||
(mType == eRadioMenuItemType && !mIsChecked)) {
if (!mContent->AsElement()->AttrValueIs(kNameSpaceID_None,
nsGkAtoms::autocheck,
nsGkAtoms::_false, eCaseMatters)) {
ModifyChecked(!mIsChecked);
}
/* the AttributeChanged code will update all the internal state */
}
nsMenuUtilsX::DispatchCommandTo(mContent, aModifierFlags, aButton);
}
nsresult nsMenuItemX::DispatchDOMEvent(const nsString& eventName,
bool* preventDefaultCalled) {
if (!mContent) {
return NS_ERROR_FAILURE;
}
// get owner document for content
nsCOMPtr<dom::Document> parentDoc = mContent->OwnerDoc();
// create DOM event
ErrorResult rv;
RefPtr<Event> event =
parentDoc->CreateEvent(u"Events"_ns, CallerType::System, rv);
if (rv.Failed()) {
NS_WARNING("Failed to create Event");
return rv.StealNSResult();
}
event->InitEvent(eventName, true, true);
// mark DOM event as trusted
event->SetTrusted(true);
// send DOM event
*preventDefaultCalled =
mContent->DispatchEvent(*event, CallerType::System, rv);
if (rv.Failed()) {
NS_WARNING("Failed to send DOM event via EventTarget");
return rv.StealNSResult();
}
return NS_OK;
}
// Walk the sibling list looking for nodes with the same name and
// uncheck them all.
void nsMenuItemX::UncheckRadioSiblings(nsIContent* aCheckedContent) {
nsAutoString myGroupName;
aCheckedContent->AsElement()->GetAttr(nsGkAtoms::name, myGroupName);
if (myGroupName.IsEmpty()) { // no groupname, nothing to do
return;
}
nsCOMPtr<nsIContent> parent = aCheckedContent->GetParent();
if (!parent) {
return;
}
// loop over siblings
for (nsIContent* sibling = parent->GetFirstChild(); sibling;
sibling = sibling->GetNextSibling()) {
if (sibling != aCheckedContent && sibling->IsElement()) { // skip this node
// if the current sibling is in the same group, clear it
if (sibling->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
myGroupName, eCaseMatters)) {
sibling->AsElement()->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked,
true);
}
}
}
}
void nsMenuItemX::SetKeyEquiv() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
// Set key shortcut and modifiers
nsAutoString keyValue;
mContent->AsElement()->GetAttr(nsGkAtoms::key, keyValue);
if (!keyValue.IsEmpty() && mContent->GetUncomposedDoc()) {
dom::Element* keyContent =
mContent->GetUncomposedDoc()->GetElementById(keyValue);
if (keyContent) {
nsAutoString keyChar;
bool hasKey = keyContent->GetAttr(nsGkAtoms::key, keyChar);
if (!hasKey || keyChar.IsEmpty()) {
nsAutoString keyCodeName;
keyContent->GetAttr(nsGkAtoms::keycode, keyCodeName);
uint32_t charCode =
nsCocoaUtils::ConvertGeckoNameToMacCharCode(keyCodeName);
if (charCode) {
keyChar.Assign(charCode);
} else {
keyChar.AssignLiteral(u" ");
}
}
nsAutoString modifiersStr;
keyContent->GetAttr(nsGkAtoms::modifiers, modifiersStr);
uint8_t modifiers =
nsMenuUtilsX::GeckoModifiersForNodeAttribute(modifiersStr);
unsigned int macModifiers =
nsMenuUtilsX::MacModifiersForGeckoModifiers(modifiers);
mNativeMenuItem.keyEquivalentModifierMask = macModifiers;
NSString* keyEquivalent =
[[NSString stringWithCharacters:(unichar*)keyChar.get()
length:keyChar.Length()] lowercaseString];
if ([keyEquivalent isEqualToString:@" "]) {
mNativeMenuItem.keyEquivalent = @"";
} else {
mNativeMenuItem.keyEquivalent = keyEquivalent;
}
return;
}
}
// if the key was removed, clear the key
mNativeMenuItem.keyEquivalent = @"";
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetBadge() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
if (@available(macOS 14.0, *)) {
nsAutoString badgeValue;
if (!mContent->AsElement()->GetAttr(nsGkAtoms::badge, badgeValue)) {
mNativeMenuItem.badge = nullptr;
return;
}
mNativeMenuItem.badge = [[[NSMenuItemBadge alloc]
initWithString:nsMenuUtilsX::GetTruncatedCocoaLabel(badgeValue)]
autorelease];
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetTitle() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
nsAutoString newLabel;
mContent->AsElement()->GetAttr(nsGkAtoms::label, newLabel);
mNativeMenuItem.title = nsMenuUtilsX::GetTruncatedCocoaLabel(newLabel);
SetAttributedTitle();
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetAttributedTitle() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
if (!mMenuParent->IsAnchoredPopUp()) {
// Use attributed titles only on anchored popups so that pulldowns and
// context menus always use native default sizing.
return;
}
if (NSAttributedString* attrString = nsMenuUtilsX::AttributedStringForContent(
mContent, mNativeMenuItem.title)) {
mNativeMenuItem.attributedTitle = attrString;
} else {
mNativeMenuItem.attributedTitle = nil;
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetChecked() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
mIsChecked = mContent->AsElement()->GetBoolAttr(nsGkAtoms::checked) ||
mContent->AsElement()->GetBoolAttr(nsGkAtoms::selected);
mNativeMenuItem.state =
mIsChecked ? NSControlStateValueOn : NSControlStateValueOff;
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetEnabled() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
// decide enabled state based on command content if it exists, otherwise do it
// based on our own content
bool isEnabled;
if (mCommandElement) {
isEnabled = !mCommandElement->GetBoolAttr(nsGkAtoms::disabled);
} else if (mContent->IsXULElement(nsGkAtoms::menucaption)) {
isEnabled = false;
} else {
isEnabled = !mContent->AsElement()->GetBoolAttr(nsGkAtoms::disabled);
}
mNativeMenuItem.enabled = isEnabled;
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetIndentationLevel() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
if (mContent->AsElement()->GetBoolAttr(nsGkAtoms::indented)) {
mNativeMenuItem.indentationLevel = 1;
} else {
mNativeMenuItem.indentationLevel = 0;
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::SetTooltip() {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
nsAutoString tooltip;
if (!mContent->AsElement()->GetAttr(nsGkAtoms::tooltiptext, tooltip)) {
mNativeMenuItem.toolTip = nil;
return;
}
mNativeMenuItem.toolTip = nsMenuUtilsX::GetTruncatedCocoaLabel(tooltip);
NS_OBJC_END_TRY_ABORT_BLOCK;
}
void nsMenuItemX::Dump(uint32_t aIndent) const {
printf("%*s - item [%p] %-16s <%s>\n", aIndent * 2, "", this,
mType == eSeparatorMenuItemType ? "----"
: [mNativeMenuItem.title UTF8String],
NS_ConvertUTF16toUTF8(mContent->NodeName()).get());
}
//
// nsChangeObserver
//
void nsMenuItemX::ObserveAttributeChanged(dom::Document* aDocument,
nsIContent* aContent,
nsAtom* aAttribute) {
NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
if (!aContent) {
return;
}
if (aContent == mContent) { // our own content node changed
if (aAttribute == nsGkAtoms::checked || aAttribute == nsGkAtoms::selected) {
// if we're a radio menu, uncheck our sibling radio items. No need to
// do any of this if we're just a normal check menu.
// XXX isn't this done by XULButtonElement as well?
if (aAttribute == nsGkAtoms::checked && mType == eRadioMenuItemType &&
mContent->AsElement()->GetBoolAttr(nsGkAtoms::checked)) {
UncheckRadioSiblings(mContent);
}
SetChecked();
mMenuParent->SetRebuild(true);
} else if (aAttribute == nsGkAtoms::hidden ||
aAttribute == nsGkAtoms::collapsed) {
bool isVisible = !nsMenuUtilsX::NodeIsHiddenOrCollapsed(mContent);
if (isVisible != mIsVisible) {
mIsVisible = isVisible;
RefPtr<nsMenuItemX> self = this;
mMenuParent->MenuChildChangedVisibility(nsMenuParentX::MenuChild(self),
isVisible);
if (mIsVisible) {
SetupIcon();
}
}
mMenuParent->SetRebuild(true);
} else if (aAttribute == nsGkAtoms::label) {
if (mType != eSeparatorMenuItemType) {
SetTitle();
}
} else if (aAttribute == nsGkAtoms::badge) {
SetBadge();
} else if (aAttribute == nsGkAtoms::key) {
SetKeyEquiv();
} else if (aAttribute == nsGkAtoms::disabled) {
SetEnabled();
} else if (aAttribute == nsGkAtoms::indented) {
SetIndentationLevel();
} else if (aAttribute == nsGkAtoms::tooltiptext) {
SetTooltip();
}
} else if (aContent == mCommandElement) {
// the only thing that really matters when the menu isn't showing is the
// enabled state since it enables/disables keyboard commands
if (aAttribute == nsGkAtoms::disabled) {
// first we sync our menu item DOM node with the command DOM node
const bool commandDisabled =
mCommandElement->GetBoolAttr(nsGkAtoms::disabled);
const bool menuDisabled =
mContent->AsElement()->GetBoolAttr(nsGkAtoms::disabled);
if (commandDisabled != menuDisabled) {
mContent->AsElement()->SetBoolAttr(nsGkAtoms::disabled,
commandDisabled);
}
// now we sync our native menu item with the command DOM node
SetEnabled();
}
} else if (aContent == mImageElement && aAttribute == nsGkAtoms::srcset) {
SetupIcon();
}
NS_OBJC_END_TRY_ABORT_BLOCK;
}
bool IsMenuStructureElement(nsIContent* aContent) {
return aContent->IsAnyOfXULElements(nsGkAtoms::menu, nsGkAtoms::menucaption,
nsGkAtoms::menuitem,
nsGkAtoms::menuseparator);
}
void nsMenuItemX::ObserveContentRemoved(dom::Document* aDocument,
nsIContent* aContainer,
nsIContent* aChild) {
MOZ_RELEASE_ASSERT(mMenuGroupOwner);
MOZ_RELEASE_ASSERT(mMenuParent);
if (aChild == mCommandElement) {
mMenuGroupOwner->UnregisterForContentChanges(mCommandElement);
mCommandElement = nullptr;
}
if (aChild == mImageElement) {
mMenuGroupOwner->UnregisterForContentChanges(mImageElement);
mImageElement = nullptr;
SetupIcon();
}
if (IsMenuStructureElement(aChild)) {
mMenuParent->SetRebuild(true);
}
}
void nsMenuItemX::ObserveContentInserted(dom::Document* aDocument,
nsIContent* aContainer,
nsIContent* aChild) {
MOZ_RELEASE_ASSERT(mMenuGroupOwner);
MOZ_RELEASE_ASSERT(mMenuParent);
// The child node could come from the custom element that is for display, so
// only rebuild the menu if the child is related to the structure of the
// menu.
if (IsMenuStructureElement(aChild)) {
mMenuParent->SetRebuild(true);
}
if (!mImageElement && aContainer == mContent &&
aChild->IsHTMLElement(nsGkAtoms::img)) {
mImageElement = aChild->AsElement();
mMenuGroupOwner->RegisterForContentChanges(aChild, this);
SetupIcon();
}
}
void nsMenuItemX::SetupIcon() {
if (mType != eRegularMenuItemType) {
// Don't support icons on checkbox and radio menuitems, for consistency with
// Windows & Linux.
return;
}
mIcon->SetupIcon(mContent);
mNativeMenuItem.image = mIcon->GetIconImage();
}
void nsMenuItemX::IconUpdated() {
mNativeMenuItem.image = mIcon->GetIconImage();
}