dom/html/HTMLMenuItemElement.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/HTMLMenuItemElement.h"
   8
   9 #include "mozilla/BasicEvents.h"
  10 #include "mozilla/EventDispatcher.h"
  11 #include "mozilla/dom/HTMLMenuItemElementBinding.h"
  12 #include "nsAttrValueInlines.h"
  13 #include "nsContentUtils.h"
  14
  15
  16 NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(MenuItem)
  17
  18 namespace mozilla {
  19 namespace dom {
  20
  21 // First bits are needed for the menuitem type.
  22 #define NS_CHECKED_IS_TOGGLED (1 << 2)
  23 #define NS_ORIGINAL_CHECKED_VALUE (1 << 3)
  24 #define NS_MENUITEM_TYPE(bits) ((bits) & ~( \
  25   NS_CHECKED_IS_TOGGLED | NS_ORIGINAL_CHECKED_VALUE))
  26
  27 enum CmdType : uint8_t
  28 {
  29   CMD_TYPE_MENUITEM = 1,
  30   CMD_TYPE_CHECKBOX,
  31   CMD_TYPE_RADIO
  32 };
  33
  34 static const nsAttrValue::EnumTable kMenuItemTypeTable[] = {
  35   { "menuitem", CMD_TYPE_MENUITEM },
  36   { "checkbox", CMD_TYPE_CHECKBOX },
  37   { "radio", CMD_TYPE_RADIO },
  38   { nullptr, 0 }
  39 };
  40
  41 static const nsAttrValue::EnumTable* kMenuItemDefaultType =
  42   &kMenuItemTypeTable[0];
  43
  44 // A base class inherited by all radio visitors.
  45 class Visitor
  46 {
  47 public:
  48   Visitor() { }
  49   virtual ~Visitor() { }
  50
  51   /**
  52    * Visit a node in the tree. This is meant to be called on all radios in a
  53    * group, sequentially. If the method returns false then the iteration is
  54    * stopped.
  55    */
  56   virtual bool Visit(HTMLMenuItemElement* aMenuItem) = 0;
  57 };
  58
  59 // Find the selected radio, see GetSelectedRadio().
  60 class GetCheckedVisitor : public Visitor
  61 {
  62 public:
  63   explicit GetCheckedVisitor(HTMLMenuItemElement** aResult)
  64     : mResult(aResult)
  65     { }
  66   virtual bool Visit(HTMLMenuItemElement* aMenuItem) override
  67   {
  68     if (aMenuItem->IsChecked()) {
  69       *mResult = aMenuItem;
  70       return false;
  71     }
  72     return true;
  73   }
  74 protected:
  75   HTMLMenuItemElement** mResult;
  76 };
  77
  78 // Deselect all radios except the one passed to the constructor.
  79 class ClearCheckedVisitor : public Visitor
  80 {
  81 public:
  82   explicit ClearCheckedVisitor(HTMLMenuItemElement* aExcludeMenuItem)
  83     : mExcludeMenuItem(aExcludeMenuItem)
  84     { }
  85   virtual bool Visit(HTMLMenuItemElement* aMenuItem) override
  86   {
  87     if (aMenuItem != mExcludeMenuItem && aMenuItem->IsChecked()) {
  88       aMenuItem->ClearChecked();
  89     }
  90     return true;
  91   }
  92 protected:
  93   HTMLMenuItemElement* mExcludeMenuItem;
  94 };
  95
  96 // Get current value of the checked dirty flag. The same value is stored on all
  97 // radios in the group, so we need to check only the first one.
  98 class GetCheckedDirtyVisitor : public Visitor
  99 {
 100 public:
 101   GetCheckedDirtyVisitor(bool* aCheckedDirty,
 102                          HTMLMenuItemElement* aExcludeMenuItem)
 103     : mCheckedDirty(aCheckedDirty),
 104       mExcludeMenuItem(aExcludeMenuItem)
 105     { }
 106   virtual bool Visit(HTMLMenuItemElement* aMenuItem) override
 107   {
 108     if (aMenuItem == mExcludeMenuItem) {
 109       return true;
 110     }
 111     *mCheckedDirty = aMenuItem->IsCheckedDirty();
 112     return false;
 113   }
 114 protected:
 115   bool* mCheckedDirty;
 116   HTMLMenuItemElement* mExcludeMenuItem;
 117 };
 118
 119 // Set checked dirty to true on all radios in the group.
 120 class SetCheckedDirtyVisitor : public Visitor
 121 {
 122 public:
 123   SetCheckedDirtyVisitor()
 124     { }
 125   virtual bool Visit(HTMLMenuItemElement* aMenuItem) override
 126   {
 127     aMenuItem->SetCheckedDirty();
 128     return true;
 129   }
 130 };
 131
 132 // A helper visitor that is used to combine two operations (visitors) to avoid
 133 // iterating over radios twice.
 134 class CombinedVisitor : public Visitor
 135 {
 136 public:
 137   CombinedVisitor(Visitor* aVisitor1, Visitor* aVisitor2)
 138     : mVisitor1(aVisitor1), mVisitor2(aVisitor2),
 139       mContinue1(true), mContinue2(true)
 140     { }
 141   virtual bool Visit(HTMLMenuItemElement* aMenuItem) override
 142   {
 143     if (mContinue1) {
 144       mContinue1 = mVisitor1->Visit(aMenuItem);
 145     }
 146     if (mContinue2) {
 147       mContinue2 = mVisitor2->Visit(aMenuItem);
 148     }
 149     return mContinue1 || mContinue2;
 150   }
 151 protected:
 152   Visitor* mVisitor1;
 153   Visitor* mVisitor2;
 154   bool mContinue1;
 155   bool mContinue2;
 156 };
 157
 158
 159 HTMLMenuItemElement::HTMLMenuItemElement(
 160   already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, FromParser aFromParser)
 161   : nsGenericHTMLElement(std::move(aNodeInfo)),
 162     mType(kMenuItemDefaultType->value),
 163     mParserCreating(false),
 164     mShouldInitChecked(false),
 165     mCheckedDirty(false),
 166     mChecked(false)
 167 {
 168   mParserCreating = aFromParser;
 169 }
 170
 171 HTMLMenuItemElement::~HTMLMenuItemElement()
 172 {
 173 }
 174
 175
 176 //NS_IMPL_ELEMENT_CLONE(HTMLMenuItemElement)
 177
 178 nsresult
 179 HTMLMenuItemElement::Clone(dom::NodeInfo* aNodeInfo, nsINode** aResult) const
 180 {
 181   *aResult = nullptr;
 182   RefPtr<HTMLMenuItemElement> it =
 183     new HTMLMenuItemElement(do_AddRef(aNodeInfo), NOT_FROM_PARSER);
 184   nsresult rv = const_cast<HTMLMenuItemElement*>(this)->CopyInnerTo(it);
 185   if (NS_SUCCEEDED(rv)) {
 186     switch (mType) {
 187       case CMD_TYPE_CHECKBOX:
 188       case CMD_TYPE_RADIO:
 189         if (mCheckedDirty) {
 190           // We no longer have our original checked state.  Set our
 191           // checked state on the clone.
 192           it->mCheckedDirty = true;
 193           it->mChecked = mChecked;
 194         }
 195         break;
 196     }
 197
 198     it.forget(aResult);
 199   }
 200
 201   return rv;
 202 }
 203
 204 void
 205 HTMLMenuItemElement::GetType(DOMString& aValue)
 206 {
 207   GetEnumAttr(nsGkAtoms::type, kMenuItemDefaultType->tag, aValue);
 208 }
 209
 210 void
 211 HTMLMenuItemElement::SetChecked(bool aChecked)
 212 {
 213   bool checkedChanged = mChecked != aChecked;
 214
 215   mChecked = aChecked;
 216
 217   if (mType == CMD_TYPE_RADIO) {
 218     if (checkedChanged) {
 219       if (mCheckedDirty) {
 220         ClearCheckedVisitor visitor(this);
 221         WalkRadioGroup(&visitor);
 222       } else {
 223         ClearCheckedVisitor visitor1(this);
 224         SetCheckedDirtyVisitor visitor2;
 225         CombinedVisitor visitor(&visitor1, &visitor2);
 226         WalkRadioGroup(&visitor);
 227       }
 228     } else if (!mCheckedDirty) {
 229       SetCheckedDirtyVisitor visitor;
 230       WalkRadioGroup(&visitor);
 231     }
 232   } else {
 233     mCheckedDirty = true;
 234   }
 235 }
 236
 237 void
 238 HTMLMenuItemElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
 239 {
 240   if (aVisitor.mEvent->mMessage == eMouseClick) {
 241
 242     bool originalCheckedValue = false;
 243     switch (mType) {
 244       case CMD_TYPE_CHECKBOX:
 245         originalCheckedValue = mChecked;
 246         SetChecked(!originalCheckedValue);
 247         aVisitor.mItemFlags |= NS_CHECKED_IS_TOGGLED;
 248         break;
 249       case CMD_TYPE_RADIO:
 250         // casting back to Element* here to resolve nsISupports ambiguity.
 251         Element* supports = GetSelectedRadio();
 252         aVisitor.mItemData = supports;
 253
 254         originalCheckedValue = mChecked;
 255         if (!originalCheckedValue) {
 256           SetChecked(true);
 257           aVisitor.mItemFlags |= NS_CHECKED_IS_TOGGLED;
 258         }
 259         break;
 260     }
 261
 262     if (originalCheckedValue) {
 263       aVisitor.mItemFlags |= NS_ORIGINAL_CHECKED_VALUE;
 264     }
 265
 266     // We must cache type because mType may change during JS event.
 267     aVisitor.mItemFlags |= mType;
 268   }
 269
 270   nsGenericHTMLElement::GetEventTargetParent(aVisitor);
 271 }
 272
 273 nsresult
 274 HTMLMenuItemElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
 275 {
 276   // Check to see if the event was cancelled.
 277   if (aVisitor.mEvent->mMessage == eMouseClick &&
 278       aVisitor.mItemFlags & NS_CHECKED_IS_TOGGLED &&
 279       aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault) {
 280     bool originalCheckedValue =
 281       !!(aVisitor.mItemFlags & NS_ORIGINAL_CHECKED_VALUE);
 282     uint8_t oldType = NS_MENUITEM_TYPE(aVisitor.mItemFlags);
 283
 284     nsCOMPtr<nsIContent> content(do_QueryInterface(aVisitor.mItemData));
 285     RefPtr<HTMLMenuItemElement> selectedRadio = HTMLMenuItemElement::FromNodeOrNull(content);
 286     if (selectedRadio) {
 287       selectedRadio->SetChecked(true);
 288       if (mType != CMD_TYPE_RADIO) {
 289         SetChecked(false);
 290       }
 291     } else if (oldType == CMD_TYPE_CHECKBOX) {
 292       SetChecked(originalCheckedValue);
 293     }
 294   }
 295
 296   return NS_OK;
 297 }
 298
 299 nsresult
 300 HTMLMenuItemElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
 301                                 nsIContent* aBindingParent)
 302 {
 303   nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
 304                                                  aBindingParent);
 305
 306   if (NS_SUCCEEDED(rv) && aDocument && mType == CMD_TYPE_RADIO) {
 307     AddedToRadioGroup();
 308   }
 309
 310   return rv;
 311 }
 312
 313 bool
 314 HTMLMenuItemElement::ParseAttribute(int32_t aNamespaceID,
 315                                     nsAtom* aAttribute,
 316                                     const nsAString& aValue,
 317                                     nsIPrincipal* aMaybeScriptedPrincipal,
 318                                     nsAttrValue& aResult)
 319 {
 320   if (aNamespaceID == kNameSpaceID_None) {
 321     if (aAttribute == nsGkAtoms::type) {
 322       return aResult.ParseEnumValue(aValue, kMenuItemTypeTable, false,
 323                                     kMenuItemDefaultType);
 324     }
 325
 326     if (aAttribute == nsGkAtoms::radiogroup) {
 327       aResult.ParseAtom(aValue);
 328       return true;
 329     }
 330   }
 331
 332   return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
 333                                               aMaybeScriptedPrincipal, aResult);
 334 }
 335
 336 void
 337 HTMLMenuItemElement::DoneCreatingElement()
 338 {
 339   mParserCreating = false;
 340
 341   if (mShouldInitChecked) {
 342     InitChecked();
 343     mShouldInitChecked = false;
 344   }
 345 }
 346
 347 void
 348 HTMLMenuItemElement::GetText(nsAString& aText)
 349 {
 350   nsAutoString text;
 351   nsContentUtils::GetNodeTextContent(this, false, text);
 352
 353   text.CompressWhitespace(true, true);
 354   aText = text;
 355 }
 356
 357 nsresult
 358 HTMLMenuItemElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
 359                                   const nsAttrValue* aValue,
 360                                   const nsAttrValue* aOldValue,
 361                                   nsIPrincipal* aSubjectPrincipal,
 362                                   bool aNotify)
 363 {
 364   if (aNameSpaceID == kNameSpaceID_None) {
 365     // Handle type changes first, since some of the later conditions in this
 366     // method look at mType and want to see the new value.
 367     if (aName == nsGkAtoms::type) {
 368       if (aValue) {
 369         mType = aValue->GetEnumValue();
 370       } else {
 371         mType = kMenuItemDefaultType->value;
 372       }
 373     }
 374
 375     if ((aName == nsGkAtoms::radiogroup || aName == nsGkAtoms::type) &&
 376         mType == CMD_TYPE_RADIO &&
 377         !mParserCreating) {
 378       if (IsInUncomposedDoc() && GetParent()) {
 379         AddedToRadioGroup();
 380       }
 381     }
 382
 383     // Checked must be set no matter what type of menuitem it is, since
 384     // GetChecked() must reflect the new value
 385     if (aName == nsGkAtoms::checked &&
 386         !mCheckedDirty) {
 387       if (mParserCreating) {
 388         mShouldInitChecked = true;
 389       } else {
 390         InitChecked();
 391       }
 392     }
 393   }
 394
 395   return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue,
 396                                             aOldValue, aSubjectPrincipal, aNotify);
 397 }
 398
 399 void
 400 HTMLMenuItemElement::WalkRadioGroup(Visitor* aVisitor)
 401 {
 402   nsIContent* parent = GetParent();
 403   if (!parent) {
 404     aVisitor->Visit(this);
 405     return;
 406   }
 407
 408   BorrowedAttrInfo info1(GetAttrInfo(kNameSpaceID_None,
 409                                nsGkAtoms::radiogroup));
 410   bool info1Empty = !info1.mValue || info1.mValue->IsEmptyString();
 411
 412   for (nsIContent* cur = parent->GetFirstChild();
 413        cur;
 414        cur = cur->GetNextSibling()) {
 415     HTMLMenuItemElement* menuitem = HTMLMenuItemElement::FromNode(cur);
 416
 417     if (!menuitem || menuitem->GetType() != CMD_TYPE_RADIO) {
 418       continue;
 419     }
 420
 421     BorrowedAttrInfo info2(menuitem->GetAttrInfo(kNameSpaceID_None,
 422                                            nsGkAtoms::radiogroup));
 423     bool info2Empty = !info2.mValue || info2.mValue->IsEmptyString();
 424
 425     if (info1Empty != info2Empty ||
 426         (info1.mValue && info2.mValue && !info1.mValue->Equals(*info2.mValue))) {
 427       continue;
 428     }
 429
 430     if (!aVisitor->Visit(menuitem)) {
 431       break;
 432     }
 433   }
 434 }
 435
 436 HTMLMenuItemElement*
 437 HTMLMenuItemElement::GetSelectedRadio()
 438 {
 439   HTMLMenuItemElement* result = nullptr;
 440
 441   GetCheckedVisitor visitor(&result);
 442   WalkRadioGroup(&visitor);
 443
 444   return result;
 445 }
 446
 447 void
 448 HTMLMenuItemElement::AddedToRadioGroup()
 449 {
 450   bool checkedDirty = mCheckedDirty;
 451   if (mChecked) {
 452     ClearCheckedVisitor visitor1(this);
 453     GetCheckedDirtyVisitor visitor2(&checkedDirty, this);
 454     CombinedVisitor visitor(&visitor1, &visitor2);
 455     WalkRadioGroup(&visitor);
 456   } else {
 457     GetCheckedDirtyVisitor visitor(&checkedDirty, this);
 458     WalkRadioGroup(&visitor);
 459   }
 460   mCheckedDirty = checkedDirty;
 461 }
 462
 463 void
 464 HTMLMenuItemElement::InitChecked()
 465 {
 466   bool defaultChecked = DefaultChecked();
 467   mChecked = defaultChecked;
 468   if (mType == CMD_TYPE_RADIO) {
 469     ClearCheckedVisitor visitor(this);
 470     WalkRadioGroup(&visitor);
 471   }
 472 }
 473
 474 JSObject*
 475 HTMLMenuItemElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 476 {
 477   return HTMLMenuItemElement_Binding::Wrap(aCx, this, aGivenProto);
 478 }
 479
 480 } // namespace dom
 481 } // namespace mozilla
 482
 483 #undef NS_ORIGINAL_CHECKED_VALUE