Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 221 insertions, 0 deletions

diff --git a/dom/html/HTMLTableCellElement.cpp b/dom/html/HTMLTableCellElement.cpp
new file mode 100644
index 0000000000..8f4ef28c2f
--- /dev/null
+++ b/dom/html/HTMLTableCellElement.cpp
@@ -0,0 +1,221 @@
+/* -*- 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/HTMLTableCellElement.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/HTMLTableElement.h"
+#include "mozilla/dom/HTMLTableRowElement.h"
+#include "mozilla/MappedDeclarations.h"
+#include "nsMappedAttributes.h"
+#include "nsAttrValueInlines.h"
+#include "celldata.h"
+#include "mozilla/dom/HTMLTableCellElementBinding.h"
+
+namespace {
+enum class StyleCellScope : uint8_t { Row, Col, Rowgroup, Colgroup };
+}  // namespace
+
+NS_IMPL_NS_NEW_HTML_ELEMENT(TableCell)
+
+namespace mozilla::dom {
+
+HTMLTableCellElement::~HTMLTableCellElement() = default;
+
+JSObject* HTMLTableCellElement::WrapNode(JSContext* aCx,
+                                         JS::Handle<JSObject*> aGivenProto) {
+  return HTMLTableCellElement_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMPL_ELEMENT_CLONE(HTMLTableCellElement)
+
+// protected method
+HTMLTableRowElement* HTMLTableCellElement::GetRow() const {
+  return HTMLTableRowElement::FromNodeOrNull(GetParent());
+}
+
+// protected method
+HTMLTableElement* HTMLTableCellElement::GetTable() const {
+  nsIContent* parent = GetParent();
+  if (!parent) {
+    return nullptr;
+  }
+
+  // parent should be a row.
+  nsIContent* section = parent->GetParent();
+  if (!section) {
+    return nullptr;
+  }
+
+  if (section->IsHTMLElement(nsGkAtoms::table)) {
+    // XHTML, without a row group.
+    return static_cast<HTMLTableElement*>(section);
+  }
+
+  // We have a row group.
+  nsIContent* result = section->GetParent();
+  if (result && result->IsHTMLElement(nsGkAtoms::table)) {
+    return static_cast<HTMLTableElement*>(result);
+  }
+
+  return nullptr;
+}
+
+int32_t HTMLTableCellElement::CellIndex() const {
+  HTMLTableRowElement* row = GetRow();
+  if (!row) {
+    return -1;
+  }
+
+  nsIHTMLCollection* cells = row->Cells();
+  if (!cells) {
+    return -1;
+  }
+
+  uint32_t numCells = cells->Length();
+  for (uint32_t i = 0; i < numCells; i++) {
+    if (cells->Item(i) == this) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+nsMappedAttributes*
+HTMLTableCellElement::GetMappedAttributesInheritedFromTable() const {
+  if (HTMLTableElement* table = GetTable()) {
+    return table->GetAttributesMappedForCell();
+  }
+
+  return nullptr;
+}
+
+void HTMLTableCellElement::GetAlign(DOMString& aValue) {
+  if (!GetAttr(kNameSpaceID_None, nsGkAtoms::align, aValue)) {
+    // There's no align attribute, ask the row for the alignment.
+    HTMLTableRowElement* row = GetRow();
+    if (row) {
+      row->GetAlign(aValue);
+    }
+  }
+}
+
+static const nsAttrValue::EnumTable kCellScopeTable[] = {
+    {"row", StyleCellScope::Row},
+    {"col", StyleCellScope::Col},
+    {"rowgroup", StyleCellScope::Rowgroup},
+    {"colgroup", StyleCellScope::Colgroup},
+    {nullptr, 0}};
+
+void HTMLTableCellElement::GetScope(DOMString& aScope) {
+  GetEnumAttr(nsGkAtoms::scope, nullptr, aScope);
+}
+
+bool HTMLTableCellElement::ParseAttribute(int32_t aNamespaceID,
+                                          nsAtom* aAttribute,
+                                          const nsAString& aValue,
+                                          nsIPrincipal* aMaybeScriptedPrincipal,
+                                          nsAttrValue& aResult) {
+  if (aNamespaceID == kNameSpaceID_None) {
+    /* ignore these attributes, stored simply as strings
+       abbr, axis, ch, headers
+    */
+    if (aAttribute == nsGkAtoms::colspan) {
+      aResult.ParseClampedNonNegativeInt(aValue, 1, 1, MAX_COLSPAN);
+      return true;
+    }
+    if (aAttribute == nsGkAtoms::rowspan) {
+      aResult.ParseClampedNonNegativeInt(aValue, 1, 0, MAX_ROWSPAN);
+      // quirks mode does not honor the special html 4 value of 0
+      if (aResult.GetIntegerValue() == 0 && InNavQuirksMode(OwnerDoc())) {
+        aResult.SetTo(1, &aValue);
+      }
+      return true;
+    }
+    if (aAttribute == nsGkAtoms::height) {
+      return aResult.ParseNonzeroHTMLDimension(aValue);
+    }
+    if (aAttribute == nsGkAtoms::width) {
+      return aResult.ParseNonzeroHTMLDimension(aValue);
+    }
+    if (aAttribute == nsGkAtoms::align) {
+      return ParseTableCellHAlignValue(aValue, aResult);
+    }
+    if (aAttribute == nsGkAtoms::bgcolor) {
+      return aResult.ParseColor(aValue);
+    }
+    if (aAttribute == nsGkAtoms::scope) {
+      return aResult.ParseEnumValue(aValue, kCellScopeTable, false);
+    }
+    if (aAttribute == nsGkAtoms::valign) {
+      return ParseTableVAlignValue(aValue, aResult);
+    }
+  }
+
+  return nsGenericHTMLElement::ParseBackgroundAttribute(
+             aNamespaceID, aAttribute, aValue, aResult) ||
+         nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
+                                              aMaybeScriptedPrincipal, aResult);
+}
+
+void HTMLTableCellElement::MapAttributesIntoRule(
+    const nsMappedAttributes* aAttributes, MappedDeclarations& aDecls) {
+  MapImageSizeAttributesInto(aAttributes, aDecls);
+
+  if (!aDecls.PropertyIsSet(eCSSProperty_white_space)) {
+    // nowrap: enum
+    if (aAttributes->GetAttr(nsGkAtoms::nowrap)) {
+      // See if our width is not a nonzero integer width.
+      const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
+      nsCompatibility mode = aDecls.Document()->GetCompatibilityMode();
+      if (!value || value->Type() != nsAttrValue::eInteger ||
+          value->GetIntegerValue() == 0 || eCompatibility_NavQuirks != mode) {
+        aDecls.SetKeywordValue(eCSSProperty_white_space,
+                               StyleWhiteSpace::Nowrap);
+      }
+    }
+  }
+
+  nsGenericHTMLElement::MapDivAlignAttributeInto(aAttributes, aDecls);
+  nsGenericHTMLElement::MapVAlignAttributeInto(aAttributes, aDecls);
+  nsGenericHTMLElement::MapBackgroundAttributesInto(aAttributes, aDecls);
+  nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aDecls);
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTableCellElement::IsAttributeMapped(const nsAtom* aAttribute) const {
+  static const MappedAttributeEntry attributes[] = {
+    {nsGkAtoms::align},
+    {nsGkAtoms::valign},
+    {nsGkAtoms::nowrap},
+#if 0
+    // XXXldb If these are implemented, they might need to move to
+    // GetAttributeChangeHint (depending on how, and preferably not).
+    { nsGkAtoms::abbr },
+    { nsGkAtoms::axis },
+    { nsGkAtoms::headers },
+    { nsGkAtoms::scope },
+#endif
+    {nsGkAtoms::width},
+    {nsGkAtoms::height},
+    {nullptr}
+  };
+
+  static const MappedAttributeEntry* const map[] = {
+      attributes,
+      sCommonAttributeMap,
+      sBackgroundAttributeMap,
+  };
+
+  return FindAttributeDependence(aAttribute, map);
+}
+
+nsMapRuleToAttributesFunc HTMLTableCellElement::GetAttributeMappingFunction()
+    const {
+  return &MapAttributesIntoRule;
+}
+
+}  // namespace mozilla::dom