gecko-dev/dom/html/HTMLMarqueeElement.cpp

/* -*- 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/HTMLMarqueeElement.h"
#include "nsGenericHTMLElement.h"
#include "nsStyleConsts.h"
#include "nsMappedAttributes.h"
#include "mozilla/dom/HTMLMarqueeElementBinding.h"
#include "mozilla/dom/CustomEvent.h"
// This is to pick up the definition of FunctionStringCallback:
#include "mozilla/dom/DataTransferItemBinding.h"

NS_IMPL_NS_NEW_HTML_ELEMENT(Marquee)

namespace mozilla {
namespace dom {

HTMLMarqueeElement::~HTMLMarqueeElement()
{
}

NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLMarqueeElement, nsGenericHTMLElement,
                                   mStartStopCallback)

NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(HTMLMarqueeElement, nsGenericHTMLElement)


NS_IMPL_ELEMENT_CLONE(HTMLMarqueeElement)

static const nsAttrValue::EnumTable kBehaviorTable[] = {
  { "scroll", 1 },
  { "slide", 2 },
  { "alternate", 3 },
  { nullptr, 0 }
};

// Default behavior value is "scroll".
static const nsAttrValue::EnumTable* kDefaultBehavior = &kBehaviorTable[0];

static const nsAttrValue::EnumTable kDirectionTable[] = {
  { "left", 1 },
  { "right", 2 },
  { "up", 3 },
  { "down", 4 },
  { nullptr, 0 }
};

// Default direction value is "left".
static const nsAttrValue::EnumTable* kDefaultDirection = &kDirectionTable[0];

bool
HTMLMarqueeElement::IsEventAttributeNameInternal(nsAtom *aName)
{
  return nsContentUtils::IsEventAttributeName(aName,
                                              EventNameType_HTML |
                                              EventNameType_HTMLMarqueeOnly);
}

JSObject*
HTMLMarqueeElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
  return dom::HTMLMarqueeElement_Binding::Wrap(aCx, this, aGivenProto);
}

void
HTMLMarqueeElement::SetStartStopCallback(FunctionStringCallback* aCallback)
{
  mStartStopCallback = aCallback;
}

void
HTMLMarqueeElement::GetBehavior(nsAString& aValue)
{
  GetEnumAttr(nsGkAtoms::behavior, kDefaultBehavior->tag, aValue);
}

void
HTMLMarqueeElement::GetDirection(nsAString& aValue)
{
  GetEnumAttr(nsGkAtoms::direction, kDefaultDirection->tag, aValue);
}

bool
HTMLMarqueeElement::ParseAttribute(int32_t aNamespaceID,
                               nsAtom* aAttribute,
                               const nsAString& aValue,
                               nsIPrincipal* aMaybeScriptedPrincipal,
                               nsAttrValue& aResult)
{
  if (aNamespaceID == kNameSpaceID_None) {
    if ((aAttribute == nsGkAtoms::width) ||
        (aAttribute == nsGkAtoms::height)) {
      return aResult.ParseSpecialIntValue(aValue);
    }
    if (aAttribute == nsGkAtoms::bgcolor) {
      return aResult.ParseColor(aValue);
    }
    if (aAttribute == nsGkAtoms::behavior) {
      return aResult.ParseEnumValue(aValue, kBehaviorTable, false, kDefaultBehavior);
    }
    if (aAttribute == nsGkAtoms::direction) {
      return aResult.ParseEnumValue(aValue, kDirectionTable, false, kDefaultDirection);
    }
    if ((aAttribute == nsGkAtoms::hspace) ||
        (aAttribute == nsGkAtoms::vspace)) {
      return aResult.ParseIntWithBounds(aValue, 0);
    }

    if (aAttribute == nsGkAtoms::loop) {
      return aResult.ParseIntValue(aValue);
    }

    if (aAttribute == nsGkAtoms::scrollamount ||
        aAttribute == nsGkAtoms::scrolldelay) {
      return aResult.ParseNonNegativeIntValue(aValue);
    }
  }

  return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
                                              aMaybeScriptedPrincipal, aResult);
}

void
HTMLMarqueeElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes, MappedDeclarations& aDecls)
{
  nsGenericHTMLElement::MapImageMarginAttributeInto(aAttributes, aDecls);
  nsGenericHTMLElement::MapImageSizeAttributesInto(aAttributes, aDecls);
  nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aDecls);
  nsGenericHTMLElement::MapBGColorInto(aAttributes, aDecls);
}

NS_IMETHODIMP_(bool)
HTMLMarqueeElement::IsAttributeMapped(const nsAtom* aAttribute) const
{
  static const MappedAttributeEntry* const map[] = {
    sImageMarginSizeAttributeMap,
    sBackgroundColorAttributeMap,
    sCommonAttributeMap
  };
  return FindAttributeDependence(aAttribute, map);
}

nsMapRuleToAttributesFunc
HTMLMarqueeElement::GetAttributeMappingFunction() const
{
  return &MapAttributesIntoRule;
}

void
HTMLMarqueeElement::Start()
{
  if (mStartStopCallback) {
    mStartStopCallback->Call(NS_LITERAL_STRING("start"));
  }
}

void
HTMLMarqueeElement::Stop()
{
  if (mStartStopCallback) {
    mStartStopCallback->Call(NS_LITERAL_STRING("stop"));
  }
}

} // namespace dom
} // namespace mozilla