/* -*- 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/. */

/* atom list for CSS pseudo-elements */

#ifndef nsCSSPseudoElements_h___

#define nsCSSPseudoElements_h___

#include "nsGkAtoms.h"

#include "mozilla/CSSEnabledState.h"

#include "mozilla/Compiler.h"

// Is this pseudo-element a CSS2 pseudo-element that can be specified

// with the single colon syntax (in addition to the double-colon syntax,

// which can be used for all pseudo-elements)?

//

// Note: We also rely on this for IsEagerlyCascadedInServo.

#define CSS_PSEUDO_ELEMENT_IS_CSS2                     (1<<0)

// Is this pseudo-element a pseudo-element that can contain other

// elements?

// (Currently pseudo-elements are either leaves of the tree (relative to

// real elements) or they contain other elements in a non-tree-like

// manner (i.e., like incorrectly-nested start and end tags).  It's

// possible that in the future there might be container pseudo-elements

// that form a properly nested tree structure.  If that happens, we

// should probably split this flag into two.)

#define CSS_PSEUDO_ELEMENT_CONTAINS_ELEMENTS           (1<<1)

// Flag to add the ability to take into account style attribute set for the

// pseudo element (by default it's ignored).

#define CSS_PSEUDO_ELEMENT_SUPPORTS_STYLE_ATTRIBUTE    (1<<2)

// Flag that indicate the pseudo-element supports a user action pseudo-class

// following it, such as :active or :hover.  This would normally correspond

// to whether the pseudo-element is tree-like, but we don't support these

// pseudo-classes on ::before and ::after generated content yet.  See

// http://dev.w3.org/csswg/selectors4/#pseudo-elements.

#define CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE  (1<<3)

// Should this pseudo-element be enabled only for UA sheets?

#define CSS_PSEUDO_ELEMENT_ENABLED_IN_UA_SHEETS (1<<4)

// Should this pseudo-element be enabled only for UA sheets and chrome

// stylesheets?

#define CSS_PSEUDO_ELEMENT_ENABLED_IN_CHROME (1<<5)

#define CSS_PSEUDO_ELEMENT_ENABLED_IN_UA_SHEETS_AND_CHROME \

  (CSS_PSEUDO_ELEMENT_ENABLED_IN_UA_SHEETS |               \

   CSS_PSEUDO_ELEMENT_ENABLED_IN_CHROME)

// Can we use the ChromeOnly document.createElement(..., { pseudo: "::foo" })

// API for creating pseudo-implementing native anonymous content in JS with this

// pseudo-element?

#define CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC           (1<<6)

// Does this pseudo-element act like an item for containers (such as flex and

// grid containers) and thus needs parent display-based style fixup?

#define CSS_PSEUDO_ELEMENT_IS_FLEX_OR_GRID_ITEM        (1<<7)

namespace mozilla {

// The total count of CSSPseudoElement is less than 256,

// so use uint8_t as its underlying type.

typedef uint8_t CSSPseudoElementTypeBase;

enum class CSSPseudoElementType : CSSPseudoElementTypeBase {

  // If the actual pseudo-elements stop being first here, change

  // GetPseudoType.

#define CSS_PSEUDO_ELEMENT(_name, _value, _flags) \

  _name,

#include "nsCSSPseudoElementList.h"

#undef CSS_PSEUDO_ELEMENT

  Count,

  InheritingAnonBox = Count, // pseudo from nsCSSAnonBoxes,

                             // IsNonInheritingAnonBox false.

  NonInheritingAnonBox, // from nsCSSAnonBoxes, IsNonInheritingAnonBox true.

#ifdef MOZ_XUL

  XULTree,

#endif

  NotPseudo,

  MAX

};

} // namespace mozilla

class nsCSSPseudoElements

{

  typedef mozilla::CSSPseudoElementType Type;

  typedef mozilla::CSSEnabledState EnabledState;

public:

  static bool IsPseudoElement(nsAtom *aAtom);

  static bool IsCSS2PseudoElement(nsAtom *aAtom);

  // This must match EAGER_PSEUDO_COUNT in Rust code.

  static const size_t kEagerPseudoCount = 4;

  static bool IsEagerlyCascadedInServo(const Type aType)

  {

    return PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_IS_CSS2);

  }

public:

#ifdef DEBUG

  static void AssertAtoms();

#endif

  // Alias nsCSSPseudoElements::foo() to alias nsGkAtoms::foo.

  // XXX Once nsGkAtoms::foo become constexpr variables, these can too.

  // See bug 1449787.

  #define CSS_PSEUDO_ELEMENT(name_, value_, flags_)       \

    static constexpr nsICSSPseudoElement* const& name_()  \

    {                                                     \

      return nsGkAtoms::PseudoElement_##name_;            \

    }

Unexecuted instantiation: nsCSSPseudoElements::after()

Unexecuted instantiation: nsCSSPseudoElements::before()

Unexecuted instantiation: nsCSSPseudoElements::firstLetter()

Unexecuted instantiation: nsCSSPseudoElements::firstLine()

  #include "nsCSSPseudoElementList.h"

  #undef CSS_PSEUDO_ELEMENT

  static Type GetPseudoType(nsAtom* aAtom, EnabledState aEnabledState);

  // Get the atom for a given Type. aType must be < CSSPseudoElementType::Count.

  // This only ever returns static atoms, so it's fine to return a raw pointer.

  static nsAtom* GetPseudoAtom(Type aType);

  // Get the atom for a given pseudo-element string (e.g. "::before").  This can

  // return dynamic atoms, for unrecognized pseudo-elements.

  static already_AddRefed<nsAtom> GetPseudoAtom(const nsAString& aPseudoElement);

  static bool PseudoElementContainsElements(const Type aType) {

    return PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_CONTAINS_ELEMENTS);

  }

  static bool PseudoElementSupportsStyleAttribute(const Type aType) {

    MOZ_ASSERT(aType < Type::Count);

    return PseudoElementHasFlags(aType,

                                 CSS_PSEUDO_ELEMENT_SUPPORTS_STYLE_ATTRIBUTE);

  }

  static bool PseudoElementSupportsUserActionState(const Type aType);

  static bool PseudoElementIsJSCreatedNAC(Type aType)

  {

    return PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC);

  }

  static bool PseudoElementIsFlexOrGridItem(const Type aType)

  {

    return PseudoElementHasFlags(aType,

                                 CSS_PSEUDO_ELEMENT_IS_FLEX_OR_GRID_ITEM);

  }

  static bool IsEnabled(Type aType, EnabledState aEnabledState)

  {

    if (!PseudoElementHasAnyFlag(

      aType, CSS_PSEUDO_ELEMENT_ENABLED_IN_UA_SHEETS_AND_CHROME)) {

      return true;

    }

    if ((aEnabledState & EnabledState::eInUASheets) &&

        PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_ENABLED_IN_UA_SHEETS)) {

      return true;

    }

    if ((aEnabledState & EnabledState::eInChrome) &&

        PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_ENABLED_IN_CHROME)) {

      return true;

    }

    return false;

  }

  static nsString PseudoTypeAsString(Type aPseudoType);

private:

  // Does the given pseudo-element have all of the flags given?

  static bool PseudoElementHasFlags(const Type aType, uint32_t aFlags)

  {

    MOZ_ASSERT(aType < Type::Count);

    return (kPseudoElementFlags[size_t(aType)] & aFlags) == aFlags;

  }

  static bool PseudoElementHasAnyFlag(const Type aType, uint32_t aFlags)

  {

    MOZ_ASSERT(aType < Type::Count);

    return (kPseudoElementFlags[size_t(aType)] & aFlags) != 0;

  }

  static const uint32_t kPseudoElementFlags[size_t(Type::Count)];

};

#endif /* nsCSSPseudoElements_h___ */