Implementation of the GreenWeb language extensions.

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 267 matching lines @@
         unsigned affectedByFocus : 1;
         unsigned affectedByHover : 1;
         unsigned affectedByActive : 1;
         unsigned affectedByDrag : 1;
 
         unsigned isLink : 1;
 
         mutable unsigned hasRemUnits : 1;
         // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
         // 63 bits
+
+        // GreenWeb QoS flags
+        // continuous: true (1, CONTINUOUS), single: false (0, DISCRETE). Here is what we defined: enum EQoSType { DISCRETE, CONTINUOUS };
+        unsigned OnclickQoSType : 1;
+        // long: true (1, LONG), short: false (0, SHORT). Here is what we defined: enum EQoSDuration { SHORT, LONG };
+        unsigned OnclickQoSVduration : 1;
+        unsigned OnscrollQoSType : 1;
+        unsigned OnscrollQoSVduration : 1;
+        unsigned OntouchstartQoSType : 1;
+        unsigned OntouchstartQoSVduration : 1;
+        unsigned OntouchendQoSType : 1;
+        unsigned OntouchendQoSVduration : 1;
+        unsigned OntouchmoveQoSType : 1;
+        unsigned OntouchmoveQoSVduration : 1;
     } noninherited_flags;
 
 // !END SYNC!
 
 protected:
     void setBitDefaults()
     {
         inherited_flags._empty_cells = initialEmptyCells();
         inherited_flags._caption_side = initialCaptionSide();
         inherited_flags._list_style_type = initialListStyleType();
@@ skipping 30 matching lines @@
         noninherited_flags.explicitInheritance = false;
         noninherited_flags.unique = false;
         noninherited_flags.emptyState = false;
         noninherited_flags.hasViewportUnits = false;
         noninherited_flags.affectedByFocus = false;
         noninherited_flags.affectedByHover = false;
         noninherited_flags.affectedByActive = false;
         noninherited_flags.affectedByDrag = false;
         noninherited_flags.isLink = false;
         noninherited_flags.hasRemUnits = false;
+        noninherited_flags.OnclickQoSType = false;
+        noninherited_flags.OnclickQoSVduration = false;
+        noninherited_flags.OnscrollQoSType = true;
+        noninherited_flags.OnscrollQoSVduration = false;
+        noninherited_flags.OntouchstartQoSType = false;
+        noninherited_flags.OntouchstartQoSVduration = false;
+        noninherited_flags.OntouchendQoSType = false;
+        noninherited_flags.OntouchendQoSVduration = false;
+        noninherited_flags.OntouchmoveQoSType = true;
+        noninherited_flags.OntouchmoveQoSVduration = false;
     }
 
 private:
     ALWAYS_INLINE ComputedStyle();
 
     enum InitialStyleTag {
         InitialStyle
     };
     ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
     ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
@@ skipping 98 matching lines @@
     bool isStyleAvailable() const;
 
     bool hasAnyPublicPseudoStyles() const;
     bool hasPseudoStyle(PseudoId) const;
     void setHasPseudoStyle(PseudoId);
     bool hasUniquePseudoStyle() const;
     bool hasPseudoElementStyle() const;
 
     // attribute getter methods
 
+    EOnclickType onclickType() const { return static_cast<EOnclickType>(noninherited_flags.OnclickQoSType); }
+    EOnclickVduration onclickVduration() const { return static_cast<EOnclickVduration>(noninherited_flags.OnclickQoSVduration); }
+    int onclickVpi() const { return rareNonInheritedData->m_onclickVpi; }
+    int onclickVpu() const { return rareNonInheritedData->m_onclickVpu; }
+
+    EOnscrollType onscrollType() const { return static_cast<EOnscrollType>(noninherited_flags.OnscrollQoSType); }
+    EOnscrollVduration onscrollVduration() const { return static_cast<EOnscrollVduration>(noninherited_flags.OnscrollQoSVduration); }
+    int onscrollVpi() const { return rareNonInheritedData->m_onscrollVpi; }
+    int onscrollVpu() const { return rareNonInheritedData->m_onscrollVpu; }
+
+    EOntouchstartType ontouchstartType() const { return static_cast<EOntouchstartType>(noninherited_flags.OntouchstartQoSType); }
+    EOntouchstartVduration ontouchstartVduration() const { return static_cast<EOntouchstartVduration>(noninherited_flags.OntouchstartQoSVduration); }
+    int ontouchstartVpi() const { return rareNonInheritedData->m_ontouchstartVpi; }
+    int ontouchstartVpu() const { return rareNonInheritedData->m_ontouchstartVpu; }
+
+    EOntouchendType ontouchendType() const { return static_cast<EOntouchendType>(noninherited_flags.OntouchendQoSType); }
+    EOntouchendVduration ontouchendVduration() const { return static_cast<EOntouchendVduration>(noninherited_flags.OntouchendQoSVduration); }
+    int ontouchendVpi() const { return rareNonInheritedData->m_ontouchendVpi; }
+    int ontouchendVpu() const { return rareNonInheritedData->m_ontouchendVpu; }
+
+    EOntouchmoveType ontouchmoveType() const { return static_cast<EOntouchmoveType>(noninherited_flags.OntouchmoveQoSType); }
+    EOntouchmoveVduration ontouchmoveVduration() const { return static_cast<EOntouchmoveVduration>(noninherited_flags.OntouchmoveQoSVduration); }
+    int ontouchmoveVpi() const { return rareNonInheritedData->m_ontouchmoveVpi; }
+    int ontouchmoveVpu() const { return rareNonInheritedData->m_ontouchmoveVpu; }
+
     EDisplay display() const { return static_cast<EDisplay>(noninherited_flags.effectiveDisplay); }
     EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_flags.originalDisplay); }
 
     const Length& left() const { return surround->offset.left(); }
     const Length& right() const { return surround->offset.right(); }
     const Length& top() const { return surround->offset.top(); }
     const Length& bottom() const { return surround->offset.bottom(); }
 
     // Accessors for positioned object edges that take into account writing mode.
     const Length& logicalLeft() const { return surround->offset.logicalLeft(writingMode()); }
@@ skipping 514 matching lines @@
     Vector<LengthPoint> scrollSnapCoordinate() const { return rareNonInheritedData->m_scrollSnap->m_coordinates; }
     LengthPoint scrollSnapDestination() const { return rareNonInheritedData->m_scrollSnap->m_destination; }
 
     const Vector<CSSPropertyID>& willChangeProperties() const { return rareNonInheritedData->m_willChange->m_properties; }
     bool willChangeContents() const { return rareNonInheritedData->m_willChange->m_contents; }
     bool willChangeScrollPosition() const { return rareNonInheritedData->m_willChange->m_scrollPosition; }
     bool hasWillChangeCompositingHint() const;
     bool hasWillChangeTransformHint() const;
     bool subtreeWillChangeContents() const { return rareInheritedData->m_subtreeWillChangeContents; }
 
-// attribute setter methods
+    // attribute setter methods
+
+    void setOnclickType(EOnclickType v)
+    {
+        noninherited_flags.OnclickQoSType = v;
+        if (v == DISCRETE) {
+            setOnclickVpi(100);
+            setOnclickVpu(300);
+        } else {
+            ASSERT(v == CONTINUOUS);
+            setOnclickVpi(16);
+            setOnclickVpu(33);
+        }
+    }
+    void setOnclickVduration(EOnclickVduration v)
+    {
+        noninherited_flags.OnclickQoSVduration = v;
+        if (v == SHORT) {
+            setOnclickVpi(100);
+            setOnclickVpu(300);
+        } else {
+            ASSERT(v == LONG);
+            setOnclickVpi(1000);
+            setOnclickVpu(10000);
+        }
+    }
+    void setOnclickVpi(int pi) { if (pi >= 0) { SET_VAR(rareNonInheritedData, m_onclickVpi, pi); } }
+    void setOnclickVpu(int pu) { if (pu >= 0) { SET_VAR(rareNonInheritedData, m_onclickVpu, pu); } }
+
+    void setOnscrollType(EOnscrollType v)
+    {
+        noninherited_flags.OnscrollQoSType = v;
+        if (v == DISCRETE) {
+            setOnscrollVpi(100);
+            setOnscrollVpu(300);
+        } else {
+            ASSERT(v == CONTINUOUS);
+            setOnscrollVpi(16);
+            setOnscrollVpu(33);
+        }
+    }
+    void setOnscrollVduration(EOnscrollVduration v)
+    {
+        noninherited_flags.OnscrollQoSVduration = v;
+        if (v == SHORT) {
+            setOnscrollVpi(100);
+            setOnscrollVpu(300);
+        } else {
+            ASSERT(v == LONG);
+            setOnscrollVpi(1000);
+            setOnscrollVpu(10000);
+        }
+    }
+    void setOnscrollVpi(int pi) { if (pi >= 0) { SET_VAR(rareNonInheritedData, m_onscrollVpi, pi); } }
+    void setOnscrollVpu(int pu) { if (pu >= 0) { SET_VAR(rareNonInheritedData, m_onscrollVpu, pu); } }
+
+    void setOntouchstartType(EOntouchstartType v)
+    {
+        noninherited_flags.OntouchstartQoSType = v;
+        if (v == DISCRETE) {
+            setOntouchstartVpi(100);
+            setOntouchstartVpu(300);
+        } else {
+            ASSERT(v == CONTINUOUS);
+            setOntouchstartVpi(16);
+            setOntouchstartVpu(33);
+        }
+    }
+    void setOntouchstartVduration(EOntouchstartVduration v)
+    {
+        noninherited_flags.OntouchstartQoSVduration = v;
+        if (v == SHORT) {
+            setOntouchstartVpi(100);
+            setOntouchstartVpu(300);
+        } else {
+            ASSERT(v == LONG);
+            setOntouchstartVpi(1000);
+            setOntouchstartVpu(10000);
+        }
+    }
+    void setOntouchstartVpi(int pi) { if (pi >= 0) { SET_VAR(rareNonInheritedData, m_ontouchstartVpi, pi); } }
+    void setOntouchstartVpu(int pu) { if (pu >= 0) { SET_VAR(rareNonInheritedData, m_ontouchstartVpu, pu); } }
+
+    void setOntouchendType(EOntouchendType v)
+    {
+        noninherited_flags.OntouchendQoSType = v;
+        if (v == DISCRETE) {
+            setOntouchendVpi(100);
+            setOntouchendVpu(300);
+        } else {
+            ASSERT(v == CONTINUOUS);
+            setOntouchendVpi(16);
+            setOntouchendVpu(33);
+        }
+    }
+    void setOntouchendVduration(EOntouchendVduration v)
+    {
+        noninherited_flags.OntouchendQoSVduration = v;
+        if (v == SHORT) {
+            setOntouchendVpi(100);
+            setOntouchendVpu(300);
+        } else {
+            ASSERT(v == LONG);
+            setOntouchendVpi(1000);
+            setOntouchendVpu(10000);
+        }
+    }
+    void setOntouchendVpi(int pi) { if (pi >= 0) { SET_VAR(rareNonInheritedData, m_ontouchendVpi, pi); } }
+    void setOntouchendVpu(int pu) { if (pu >= 0) { SET_VAR(rareNonInheritedData, m_ontouchendVpu, pu); } }
+
+    void setOntouchmoveType(EOntouchmoveType v)
+    {
+        noninherited_flags.OntouchmoveQoSType = v;
+        if (v == DISCRETE) {
+            setOntouchmoveVpi(100);
+            setOntouchmoveVpu(300);
+        } else {
+            ASSERT(v == CONTINUOUS);
+            setOntouchmoveVpi(16);
+            setOntouchmoveVpu(33);
+        }
+    }
+    void setOntouchmoveVduration(EOntouchmoveVduration v)
+    {
+        noninherited_flags.OntouchmoveQoSVduration = v;
+        if (v == SHORT) {
+            setOntouchmoveVpi(100);
+            setOntouchmoveVpu(300);
+        } else {
+            ASSERT(v == LONG);
+            setOntouchmoveVpi(1000);
+            setOntouchmoveVpu(10000);
+        }
+    }
+    void setOntouchmoveVpi(int pi) { if (pi >= 0) { SET_VAR(rareNonInheritedData, m_ontouchmoveVpi, pi); } }
+    void setOntouchmoveVpu(int pu) { if (pu >= 0) { SET_VAR(rareNonInheritedData, m_ontouchmoveVpu, pu); } }
 
     void setDisplay(EDisplay v) { noninherited_flags.effectiveDisplay = v; }
     void setOriginalDisplay(EDisplay v) { noninherited_flags.originalDisplay = v; }
     void setPosition(EPosition v) { noninherited_flags.position = v; }
     void setFloating(EFloat v) { noninherited_flags.floating = v; }
 
     void setLeft(const Length& v) { SET_VAR(surround, offset.m_left, v); }
     void setRight(const Length& v) { SET_VAR(surround, offset.m_right, v); }
     void setTop(const Length& v) { SET_VAR(surround, offset.m_top, v); }
     void setBottom(const Length& v) { SET_VAR(surround, offset.m_bottom, v); }
@@ skipping 599 matching lines @@
 
     bool borderObscuresBackground() const;
     void getBorderEdgeInfo(BorderEdge edges[], bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true) const;
 
     void setHasAuthorBackground(bool authorBackground) { SET_VAR(rareNonInheritedData, m_hasAuthorBackground, authorBackground); }
     void setHasAuthorBorder(bool authorBorder) { SET_VAR(rareNonInheritedData, m_hasAuthorBorder, authorBorder); }
     bool hasAuthorBackground() const { return rareNonInheritedData->m_hasAuthorBackground; };
     bool hasAuthorBorder() const { return rareNonInheritedData->m_hasAuthorBorder; };
 
     // Initial values for all the properties
+    static EOnclickType initialOnclickType() { return DISCRETE; }
+    static EOnclickVduration initialOnclickVduration() { return SHORT; }
+    static int initialOnclickVpi() { return 100; }
+    static int initialOnclickVpu() { return 300; }
+
+    static EOnscrollType initialOnscrollType() { return CONTINUOUS; }
+    static EOnscrollVduration initialOnscrollVduration() { return SHORT; }
+    static int initialOnscrollVpi() { return 16; }
+    static int initialOnscrollVpu() { return 33; }
+
+    static EOntouchstartType initialOntouchstartType() { return DISCRETE; }
+    static EOntouchstartVduration initialOntouchstartVduration() { return SHORT; }
+    static int initialOntouchstartVpi() { return 100; }
+    static int initialOntouchstartVpu() { return 300; }
+
+    static EOntouchendType initialOntouchendType() { return DISCRETE; }
+    static EOntouchendVduration initialOntouchendVduration() { return SHORT; }
+    static int initialOntouchendVpi() { return 100; }
+    static int initialOntouchendVpu() { return 300; }
+
+    static EOntouchmoveType initialOntouchmoveType() { return CONTINUOUS; }
+    static EOntouchmoveVduration initialOntouchmoveVduration() { return SHORT; }
+    static int initialOntouchmoveVpi() { return 16; }
+    static int initialOntouchmoveVpu() { return 33; }
+
     static EBorderCollapse initialBorderCollapse() { return BSEPARATE; }
     static EBorderStyle initialBorderStyle() { return BNONE; }
     static OutlineIsAuto initialOutlineStyleIsAuto() { return AUTO_OFF; }
     static NinePieceImage initialNinePieceImage() { return NinePieceImage(); }
     static LengthSize initialBorderRadius() { return LengthSize(Length(0, Fixed), Length(0, Fixed)); }
     static ECaptionSide initialCaptionSide() { return CAPTOP; }
     static EClear initialClear() { return CNONE; }
     static LengthBox initialClip() { return LengthBox(); }
     static TextDirection initialDirection() { return LTR; }
     static WritingMode initialWritingMode() { return TopToBottomWritingMode; }
@@ skipping 366 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags.pseudoBits & PSEUDO_ELEMENT_MASK;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h