dom/svg/SVGAElement.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/SVGAElement.h"
   8
   9 #include "mozilla/Attributes.h"
  10 #include "mozilla/EventDispatcher.h"
  11 #include "mozilla/dom/BindContext.h"
  12 #include "mozilla/dom/DocumentInlines.h"
  13 #include "mozilla/dom/SVGAElementBinding.h"
  14 #include "nsCOMPtr.h"
  15 #include "nsContentUtils.h"
  16 #include "nsGkAtoms.h"
  17 #include "nsIContentInlines.h"
  18 #include "nsIURI.h"
  19
  20 NS_IMPL_NS_NEW_SVG_ELEMENT(A)
  21
  22 namespace mozilla::dom {
  23
  24 JSObject* SVGAElement::WrapNode(JSContext* aCx,
  25                                 JS::Handle<JSObject*> aGivenProto) {
  26   return SVGAElement_Binding::Wrap(aCx, this, aGivenProto);
  27 }
  28
  29 SVGElement::StringInfo SVGAElement::sStringInfo[3] = {
  30     {nsGkAtoms::href, kNameSpaceID_None, true},
  31     {nsGkAtoms::href, kNameSpaceID_XLink, true},
  32     {nsGkAtoms::target, kNameSpaceID_None, true}};
  33
  34 //----------------------------------------------------------------------
  35 // nsISupports methods
  36
  37 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SVGAElement)
  38   NS_INTERFACE_MAP_ENTRY(Link)
  39 NS_INTERFACE_MAP_END_INHERITING(SVGAElementBase)
  40
  41 NS_IMPL_CYCLE_COLLECTION_INHERITED(SVGAElement, SVGAElementBase, mRelList)
  42
  43 NS_IMPL_ADDREF_INHERITED(SVGAElement, SVGAElementBase)
  44 NS_IMPL_RELEASE_INHERITED(SVGAElement, SVGAElementBase)
  45
  46 //----------------------------------------------------------------------
  47 // Implementation
  48
  49 SVGAElement::SVGAElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
  50     : SVGAElementBase(std::move(aNodeInfo)), Link(this) {}
  51
  52 already_AddRefed<DOMSVGAnimatedString> SVGAElement::Href() {
  53   return mStringAttributes[HREF].IsExplicitlySet()
  54              ? mStringAttributes[HREF].ToDOMAnimatedString(this)
  55              : mStringAttributes[XLINK_HREF].ToDOMAnimatedString(this);
  56 }
  57
  58 //----------------------------------------------------------------------
  59 // nsINode methods
  60
  61 void SVGAElement::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
  62   Element::GetEventTargetParent(aVisitor);
  63
  64   GetEventTargetParentForLinks(aVisitor);
  65 }
  66
  67 nsresult SVGAElement::PostHandleEvent(EventChainPostVisitor& aVisitor) {
  68   return PostHandleEventForLinks(aVisitor);
  69 }
  70
  71 NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGAElement)
  72
  73 //----------------------------------------------------------------------
  74
  75 already_AddRefed<DOMSVGAnimatedString> SVGAElement::Target() {
  76   return mStringAttributes[TARGET].ToDOMAnimatedString(this);
  77 }
  78
  79 void SVGAElement::GetDownload(nsAString& aDownload) {
  80   GetAttr(nsGkAtoms::download, aDownload);
  81 }
  82
  83 void SVGAElement::SetDownload(const nsAString& aDownload, ErrorResult& rv) {
  84   SetAttr(nsGkAtoms::download, aDownload, rv);
  85 }
  86
  87 void SVGAElement::GetPing(nsAString& aPing) { GetAttr(nsGkAtoms::ping, aPing); }
  88
  89 void SVGAElement::SetPing(const nsAString& aPing, ErrorResult& rv) {
  90   SetAttr(nsGkAtoms::ping, aPing, rv);
  91 }
  92
  93 void SVGAElement::GetRel(nsAString& aRel) { GetAttr(nsGkAtoms::rel, aRel); }
  94
  95 void SVGAElement::SetRel(const nsAString& aRel, ErrorResult& rv) {
  96   SetAttr(nsGkAtoms::rel, aRel, rv);
  97 }
  98
  99 void SVGAElement::GetReferrerPolicy(nsAString& aPolicy) {
 100   GetEnumAttr(nsGkAtoms::referrerpolicy, "", aPolicy);
 101 }
 102
 103 void SVGAElement::SetReferrerPolicy(const nsAString& aPolicy,
 104                                     mozilla::ErrorResult& rv) {
 105   SetAttr(nsGkAtoms::referrerpolicy, aPolicy, rv);
 106 }
 107
 108 nsDOMTokenList* SVGAElement::RelList() {
 109   if (!mRelList) {
 110     mRelList =
 111         new nsDOMTokenList(this, nsGkAtoms::rel, sAnchorAndFormRelValues);
 112   }
 113   return mRelList;
 114 }
 115
 116 void SVGAElement::GetHreflang(nsAString& aHreflang) {
 117   GetAttr(nsGkAtoms::hreflang, aHreflang);
 118 }
 119
 120 void SVGAElement::SetHreflang(const nsAString& aHreflang,
 121                               mozilla::ErrorResult& rv) {
 122   SetAttr(nsGkAtoms::hreflang, aHreflang, rv);
 123 }
 124
 125 void SVGAElement::GetType(nsAString& aType) { GetAttr(nsGkAtoms::type, aType); }
 126
 127 void SVGAElement::SetType(const nsAString& aType, mozilla::ErrorResult& rv) {
 128   SetAttr(nsGkAtoms::type, aType, rv);
 129 }
 130
 131 void SVGAElement::GetText(nsAString& aText, mozilla::ErrorResult& rv) const {
 132   if (NS_WARN_IF(
 133           !nsContentUtils::GetNodeTextContent(this, true, aText, fallible))) {
 134     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
 135   }
 136 }
 137
 138 void SVGAElement::SetText(const nsAString& aText, mozilla::ErrorResult& rv) {
 139   rv = nsContentUtils::SetNodeTextContent(this, aText, false);
 140 }
 141
 142 //----------------------------------------------------------------------
 143 // nsIContent methods
 144
 145 nsresult SVGAElement::BindToTree(BindContext& aContext, nsINode& aParent) {
 146   nsresult rv = SVGAElementBase::BindToTree(aContext, aParent);
 147   NS_ENSURE_SUCCESS(rv, rv);
 148   Link::BindToTree(aContext);
 149   return NS_OK;
 150 }
 151
 152 void SVGAElement::UnbindFromTree(UnbindContext& aContext) {
 153   SVGAElementBase::UnbindFromTree(aContext);
 154   // Without removing the link state we risk a dangling pointer
 155   // in the mStyledLinks hashtable
 156   Link::UnbindFromTree();
 157 }
 158
 159 int32_t SVGAElement::TabIndexDefault() { return 0; }
 160
 161 Focusable SVGAElement::IsFocusableWithoutStyle(bool aWithMouse) {
 162   Focusable result;
 163   if (IsSVGFocusable(&result.mFocusable, &result.mTabIndex)) {
 164     return result;
 165   }
 166
 167   if (!OwnerDoc()->LinkHandlingEnabled()) {
 168     return {};
 169   }
 170
 171   // Links that are in an editable region should never be focusable, even if
 172   // they are in a contenteditable="false" region.
 173   if (nsContentUtils::IsNodeInEditableRegion(this)) {
 174     return {};
 175   }
 176
 177   if (GetTabIndexAttrValue().isNothing()) {
 178     // check whether we're actually a link
 179     if (!IsLink()) {
 180       // Not tabbable or focusable without href (bug 17605), unless
 181       // forced to be via presence of nonnegative tabindex attribute
 182       return {};
 183     }
 184   }
 185   if ((sTabFocusModel & eTabFocus_linksMask) == 0) {
 186     result.mTabIndex = -1;
 187   }
 188   return result;
 189 }
 190
 191 bool SVGAElement::HasHref() const {
 192   // Currently our SMIL implementation does not modify the DOM attributes. Once
 193   // we implement the SVG 2 SMIL behaviour this can be removed.
 194   return mStringAttributes[HREF].IsExplicitlySet() ||
 195          mStringAttributes[XLINK_HREF].IsExplicitlySet();
 196 }
 197
 198 already_AddRefed<nsIURI> SVGAElement::GetHrefURI() const {
 199   // Optimization: check for href first for early return
 200   bool useBareHref = mStringAttributes[HREF].IsExplicitlySet();
 201   if (useBareHref || mStringAttributes[XLINK_HREF].IsExplicitlySet()) {
 202     // Get absolute URI
 203     nsAutoString str;
 204     const uint8_t idx = useBareHref ? HREF : XLINK_HREF;
 205     mStringAttributes[idx].GetAnimValue(str, this);
 206     nsCOMPtr<nsIURI> uri;
 207     nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri), str,
 208                                               OwnerDoc(), GetBaseURI());
 209     return uri.forget();
 210   }
 211   return nullptr;
 212 }
 213
 214 void SVGAElement::GetLinkTarget(nsAString& aTarget) {
 215   mStringAttributes[TARGET].GetAnimValue(aTarget, this);
 216   if (aTarget.IsEmpty()) {
 217     static Element::AttrValuesArray sShowVals[] = {nsGkAtoms::_new,
 218                                                    nsGkAtoms::replace, nullptr};
 219
 220     switch (FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::show, sShowVals,
 221                             eCaseMatters)) {
 222       case 0:
 223         aTarget.AssignLiteral("_blank");
 224         return;
 225       case 1:
 226         return;
 227     }
 228     Document* ownerDoc = OwnerDoc();
 229     if (ownerDoc) {
 230       ownerDoc->GetBaseTarget(aTarget);
 231     }
 232   }
 233 }
 234
 235 void SVGAElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
 236                                const nsAttrValue* aValue,
 237                                const nsAttrValue* aOldValue,
 238                                nsIPrincipal* aMaybeScriptedPrincipal,
 239                                bool aNotify) {
 240   if (aName == nsGkAtoms::href && (aNameSpaceID == kNameSpaceID_XLink ||
 241                                    aNameSpaceID == kNameSpaceID_None)) {
 242     // We can't assume that null aValue means we no longer have an href, because
 243     // we could be unsetting xlink:href but still have a null-namespace href, or
 244     // vice versa.  But we can fast-path the case when we _do_ have a new value.
 245     Link::ResetLinkState(aNotify, aValue || Link::ElementHasHref());
 246   }
 247
 248   return SVGAElementBase::AfterSetAttr(aNameSpaceID, aName, aValue, aOldValue,
 249                                        aMaybeScriptedPrincipal, aNotify);
 250 }
 251
 252 //----------------------------------------------------------------------
 253 // SVGElement methods
 254
 255 SVGElement::StringAttributesInfo SVGAElement::GetStringInfo() {
 256   return StringAttributesInfo(mStringAttributes, sStringInfo,
 257                               ArrayLength(sStringInfo));
 258 }
 259
 260 }  // namespace mozilla::dom