#ifndef CSSSelector_h
#define CSSSelector_h
#include "QualifiedName.h"
#include "RenderStyleConstants.h"
#include <wtf/Noncopyable.h>
namespace WebCore {
class CSSSelectorList;
class CSSSelector {
WTF_MAKE_FAST_ALLOCATED;
public:
CSSSelector();
CSSSelector(const CSSSelector&);
explicit CSSSelector(const QualifiedName&, bool tagIsForNamespaceRule = false);
~CSSSelector();
String selectorText(const String& = "") const;
bool operator==(const CSSSelector&) const;
unsigned specificity() const;
enum Match {
Unknown = 0,
Tag,
Id,
Class,
Exact,
Set,
List,
Hyphen,
PseudoClass,
PseudoElement,
Contain, Begin, End, PagePseudoClass
};
enum Relation {
Descendant = 0,
Child,
DirectAdjacent,
IndirectAdjacent,
SubSelector,
ShadowDescendant,
};
enum PseudoClassType {
PseudoClassUnknown = 0,
PseudoClassEmpty,
PseudoClassFirstChild,
PseudoClassFirstOfType,
PseudoClassLastChild,
PseudoClassLastOfType,
PseudoClassOnlyChild,
PseudoClassOnlyOfType,
PseudoClassNthChild,
PseudoClassNthOfType,
PseudoClassNthLastChild,
PseudoClassNthLastOfType,
PseudoClassLink,
PseudoClassVisited,
PseudoClassAny,
PseudoClassAnyLink,
PseudoClassAutofill,
PseudoClassHover,
PseudoClassDrag,
PseudoClassFocus,
PseudoClassActive,
PseudoClassChecked,
PseudoClassEnabled,
PseudoClassFullPageMedia,
PseudoClassDefault,
PseudoClassDisabled,
PseudoClassOptional,
PseudoClassRequired,
PseudoClassReadOnly,
PseudoClassReadWrite,
PseudoClassValid,
PseudoClassInvalid,
PseudoClassIndeterminate,
PseudoClassTarget,
PseudoClassLang,
PseudoClassNot,
PseudoClassRoot,
PseudoClassScope,
PseudoClassWindowInactive,
PseudoClassCornerPresent,
PseudoClassDecrement,
PseudoClassIncrement,
PseudoClassHorizontal,
PseudoClassVertical,
PseudoClassStart,
PseudoClassEnd,
PseudoClassDoubleButton,
PseudoClassSingleButton,
PseudoClassNoButton,
#if ENABLE(FULLSCREEN_API)
PseudoClassFullScreen,
PseudoClassFullScreenDocument,
PseudoClassFullScreenAncestor,
PseudoClassAnimatingFullScreenTransition,
#endif
PseudoClassInRange,
PseudoClassOutOfRange,
#if ENABLE(VIDEO_TRACK)
PseudoClassFuture,
PseudoClassPast,
#endif
};
enum PseudoElementType {
PseudoElementUnknown = 0,
PseudoElementAfter,
PseudoElementBefore,
#if ENABLE(VIDEO_TRACK)
PseudoElementCue,
#endif
PseudoElementFirstLetter,
PseudoElementFirstLine,
PseudoElementResizer,
PseudoElementScrollbar,
PseudoElementScrollbarButton,
PseudoElementScrollbarCorner,
PseudoElementScrollbarThumb,
PseudoElementScrollbarTrack,
PseudoElementScrollbarTrackPiece,
PseudoElementSelection,
PseudoElementUserAgentCustom,
PseudoElementWebKitCustom,
};
enum PagePseudoClassType {
PagePseudoClassFirst = 1,
PagePseudoClassLeft,
PagePseudoClassRight,
};
enum MarginBoxType {
TopLeftCornerMarginBox,
TopLeftMarginBox,
TopCenterMarginBox,
TopRightMarginBox,
TopRightCornerMarginBox,
BottomLeftCornerMarginBox,
BottomLeftMarginBox,
BottomCenterMarginBox,
BottomRightMarginBox,
BottomRightCornerMarginBox,
LeftTopMarginBox,
LeftMiddleMarginBox,
LeftBottomMarginBox,
RightTopMarginBox,
RightMiddleMarginBox,
RightBottomMarginBox,
};
static PseudoElementType parsePseudoElementType(const String&);
static PseudoId pseudoId(PseudoElementType);
const CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
const QualifiedName& tagQName() const;
const AtomicString& value() const;
const QualifiedName& attribute() const;
const AtomicString& attributeCanonicalLocalName() const;
const AtomicString& argument() const { return m_hasRareData ? m_data.m_rareData->m_argument : nullAtom; }
const CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : 0; }
void setPseudoElementType(PseudoElementType pseudoElementType) { m_pseudoType = pseudoElementType; }
void setPagePseudoType(PagePseudoClassType pagePseudoType) { m_pseudoType = pagePseudoType; }
void setValue(const AtomicString&);
void setAttribute(const QualifiedName&, bool isCaseInsensitive);
void setArgument(const AtomicString&);
void setSelectorList(std::unique_ptr<CSSSelectorList>);
bool parseNth() const;
bool matchNth(int count) const;
int nthA() const;
int nthB() const;
PseudoClassType pseudoClassType() const
{
ASSERT(m_match == PseudoClass);
return static_cast<PseudoClassType>(m_pseudoType);
}
PseudoElementType pseudoElementType() const
{
ASSERT(m_match == PseudoElement);
return static_cast<PseudoElementType>(m_pseudoType);
}
PagePseudoClassType pagePseudoClassType() const
{
ASSERT(m_match == PagePseudoClass);
return static_cast<PagePseudoClassType>(m_pseudoType);
}
bool matchesPseudoElement() const;
bool isUnknownPseudoElement() const;
bool isCustomPseudoElement() const;
bool isSiblingSelector() const;
bool isAttributeSelector() const;
Relation relation() const { return static_cast<Relation>(m_relation); }
bool isLastInSelectorList() const { return m_isLastInSelectorList; }
void setLastInSelectorList() { m_isLastInSelectorList = true; }
bool isLastInTagHistory() const { return m_isLastInTagHistory; }
void setNotLastInTagHistory() { m_isLastInTagHistory = false; }
bool isSimple() const;
bool isForPage() const { return m_isForPage; }
void setForPage() { m_isForPage = true; }
unsigned m_relation : 3; mutable unsigned m_match : 4; mutable unsigned m_pseudoType : 8;
private:
mutable bool m_parsedNth : 1; bool m_isLastInSelectorList : 1;
bool m_isLastInTagHistory : 1;
bool m_hasRareData : 1;
bool m_isForPage : 1;
bool m_tagIsForNamespaceRule : 1;
unsigned specificityForOneSelector() const;
unsigned specificityForPage() const;
CSSSelector& operator=(const CSSSelector&);
struct RareData : public RefCounted<RareData> {
static PassRefPtr<RareData> create(PassRefPtr<AtomicStringImpl> value) { return adoptRef(new RareData(value)); }
~RareData();
bool parseNth();
bool matchNth(int count);
AtomicStringImpl* m_value; int m_a; int m_b; QualifiedName m_attribute; AtomicString m_attributeCanonicalLocalName;
AtomicString m_argument; std::unique_ptr<CSSSelectorList> m_selectorList;
private:
RareData(PassRefPtr<AtomicStringImpl> value);
};
void createRareData();
union DataUnion {
DataUnion() : m_value(0) { }
AtomicStringImpl* m_value;
QualifiedName::QualifiedNameImpl* m_tagQName;
RareData* m_rareData;
} m_data;
};
inline const QualifiedName& CSSSelector::attribute() const
{
ASSERT(isAttributeSelector());
ASSERT(m_hasRareData);
return m_data.m_rareData->m_attribute;
}
inline const AtomicString& CSSSelector::attributeCanonicalLocalName() const
{
ASSERT(isAttributeSelector());
ASSERT(m_hasRareData);
return m_data.m_rareData->m_attributeCanonicalLocalName;
}
inline bool CSSSelector::matchesPseudoElement() const
{
return m_match == PseudoElement;
}
inline bool CSSSelector::isUnknownPseudoElement() const
{
return m_match == PseudoElement && m_pseudoType == PseudoElementUnknown;
}
inline bool CSSSelector::isCustomPseudoElement() const
{
return m_match == PseudoElement && (m_pseudoType == PseudoElementUserAgentCustom || m_pseudoType == PseudoElementWebKitCustom);
}
static inline bool pseudoClassIsRelativeToSiblings(CSSSelector::PseudoClassType type)
{
return type == CSSSelector::PseudoClassEmpty
|| type == CSSSelector::PseudoClassFirstChild
|| type == CSSSelector::PseudoClassFirstOfType
|| type == CSSSelector::PseudoClassLastChild
|| type == CSSSelector::PseudoClassLastOfType
|| type == CSSSelector::PseudoClassOnlyChild
|| type == CSSSelector::PseudoClassOnlyOfType
|| type == CSSSelector::PseudoClassNthChild
|| type == CSSSelector::PseudoClassNthOfType
|| type == CSSSelector::PseudoClassNthLastChild
|| type == CSSSelector::PseudoClassNthLastOfType;
}
inline bool CSSSelector::isSiblingSelector() const
{
return m_relation == DirectAdjacent
|| m_relation == IndirectAdjacent
|| (m_match == CSSSelector::PseudoClass && pseudoClassIsRelativeToSiblings(pseudoClassType()));
}
inline bool CSSSelector::isAttributeSelector() const
{
return m_match == CSSSelector::Exact
|| m_match == CSSSelector::Set
|| m_match == CSSSelector::List
|| m_match == CSSSelector::Hyphen
|| m_match == CSSSelector::Contain
|| m_match == CSSSelector::Begin
|| m_match == CSSSelector::End;
}
inline void CSSSelector::setValue(const AtomicString& value)
{
ASSERT(m_match != Tag);
if (m_hasRareData) {
if (m_data.m_rareData->m_value)
m_data.m_rareData->m_value->deref();
m_data.m_rareData->m_value = value.impl();
m_data.m_rareData->m_value->ref();
return;
}
if (m_data.m_value)
m_data.m_value->deref();
m_data.m_value = value.impl();
m_data.m_value->ref();
}
inline CSSSelector::CSSSelector()
: m_relation(Descendant)
, m_match(Unknown)
, m_pseudoType(0)
, m_parsedNth(false)
, m_isLastInSelectorList(false)
, m_isLastInTagHistory(true)
, m_hasRareData(false)
, m_isForPage(false)
, m_tagIsForNamespaceRule(false)
{
}
inline CSSSelector::CSSSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
: m_relation(Descendant)
, m_match(Tag)
, m_pseudoType(0)
, m_parsedNth(false)
, m_isLastInSelectorList(false)
, m_isLastInTagHistory(true)
, m_hasRareData(false)
, m_isForPage(false)
, m_tagIsForNamespaceRule(tagIsForNamespaceRule)
{
m_data.m_tagQName = tagQName.impl();
m_data.m_tagQName->ref();
}
inline CSSSelector::CSSSelector(const CSSSelector& o)
: m_relation(o.m_relation)
, m_match(o.m_match)
, m_pseudoType(o.m_pseudoType)
, m_parsedNth(o.m_parsedNth)
, m_isLastInSelectorList(o.m_isLastInSelectorList)
, m_isLastInTagHistory(o.m_isLastInTagHistory)
, m_hasRareData(o.m_hasRareData)
, m_isForPage(o.m_isForPage)
, m_tagIsForNamespaceRule(o.m_tagIsForNamespaceRule)
{
if (o.m_match == Tag) {
m_data.m_tagQName = o.m_data.m_tagQName;
m_data.m_tagQName->ref();
} else if (o.m_hasRareData) {
m_data.m_rareData = o.m_data.m_rareData;
m_data.m_rareData->ref();
} else if (o.m_data.m_value) {
m_data.m_value = o.m_data.m_value;
m_data.m_value->ref();
}
}
inline CSSSelector::~CSSSelector()
{
if (m_match == Tag)
m_data.m_tagQName->deref();
else if (m_hasRareData)
m_data.m_rareData->deref();
else if (m_data.m_value)
m_data.m_value->deref();
}
inline const QualifiedName& CSSSelector::tagQName() const
{
ASSERT(m_match == Tag);
return *reinterpret_cast<const QualifiedName*>(&m_data.m_tagQName);
}
inline const AtomicString& CSSSelector::value() const
{
ASSERT(m_match != Tag);
return *reinterpret_cast<const AtomicString*>(m_hasRareData ? &m_data.m_rareData->m_value : &m_data.m_value);
}
}
#endif // CSSSelector_h