Home | History | Annotate | Download | only in style 
      1 /*
      2  * Copyright (C) 2000 Lars Knoll (knoll (at) kde.org)
      3  *           (C) 2000 Antti Koivisto (koivisto (at) kde.org)
      4  *           (C) 2000 Dirk Mueller (mueller (at) kde.org)
      5  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
      6  * Copyright (C) 2006 Graham Dennis (graham.dennis (at) gmail.com)
      7  *
      8  * This library is free software; you can redistribute it and/or
      9  * modify it under the terms of the GNU Library General Public
     10  * License as published by the Free Software Foundation; either
     11  * version 2 of the License, or (at your option) any later version.
     12  *
     13  * This library is distributed in the hope that it will be useful,
     14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     16  * Library General Public License for more details.
     17  *
     18  * You should have received a copy of the GNU Library General Public License
     19  * along with this library; see the file COPYING.LIB.  If not, write to
     20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21  * Boston, MA 02110-1301, USA.
     22  *
     23  */
     24 
     25 #ifndef CounterDirectives_h
     26 #define CounterDirectives_h
     27 
     28 #include "wtf/HashMap.h"
     29 #include "wtf/MathExtras.h"
     30 #include "wtf/RefPtr.h"
     31 #include "wtf/text/AtomicString.h"
     32 #include "wtf/text/AtomicStringHash.h"
     33 
     34 namespace blink {
     35 
     36 class CounterDirectives {
     37 public:
     38     CounterDirectives()
     39         : m_isResetSet(false)
     40         , m_isIncrementSet(false)
     41         , m_resetValue(0)
     42         , m_incrementValue(0)
     43     {
     44     }
     45 
     46     // FIXME: The code duplication here could possibly be replaced by using two
     47     // maps, or by using a container that held two generic Directive objects.
     48 
     49     bool isReset() const { return m_isResetSet; }
     50     int resetValue() const { return m_resetValue; }
     51     void setResetValue(int value)
     52     {
     53         m_resetValue = value;
     54         m_isResetSet = true;
     55     }
     56     void clearReset()
     57     {
     58         m_resetValue = 0;
     59         m_isResetSet = false;
     60     }
     61     void inheritReset(CounterDirectives& parent)
     62     {
     63         m_resetValue = parent.m_resetValue;
     64         m_isResetSet = parent.m_isResetSet;
     65     }
     66 
     67     bool isIncrement() const { return m_isIncrementSet; }
     68     int incrementValue() const { return m_incrementValue; }
     69     void addIncrementValue(int value)
     70     {
     71         m_incrementValue = clampToInteger((double)m_incrementValue + value);
     72         m_isIncrementSet = true;
     73     }
     74     void clearIncrement()
     75     {
     76         m_incrementValue = 0;
     77         m_isIncrementSet = false;
     78     }
     79     void inheritIncrement(CounterDirectives& parent)
     80     {
     81         m_incrementValue = parent.m_incrementValue;
     82         m_isIncrementSet = parent.m_isIncrementSet;
     83     }
     84 
     85     bool isDefined() const { return isReset() || isIncrement(); }
     86 
     87     int combinedValue() const
     88     {
     89         ASSERT(m_isResetSet || !m_resetValue);
     90         ASSERT(m_isIncrementSet || !m_incrementValue);
     91         // FIXME: Shouldn't allow overflow here.
     92         return m_resetValue + m_incrementValue;
     93     }
     94 
     95 private:
     96     bool m_isResetSet;
     97     bool m_isIncrementSet;
     98     int m_resetValue;
     99     int m_incrementValue;
    100 };
    101 
    102 bool operator==(const CounterDirectives&, const CounterDirectives&);
    103 inline bool operator!=(const CounterDirectives& a, const CounterDirectives& b) { return !(a == b); }
    104 
    105 typedef HashMap<AtomicString, CounterDirectives> CounterDirectiveMap;
    106 
    107 PassOwnPtr<CounterDirectiveMap> clone(const CounterDirectiveMap&);
    108 
    109 } // namespace blink
    110 
    111 #endif // CounterDirectives_h
    112