DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (d38398e5144e)

VCS Links

nsRuleData

Macros

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */

/*
 * temporary (expanded) representation of property-value pairs used to
 * hold data from matched rules during style data computation.
 */

#ifndef nsRuleData_h_
#define nsRuleData_h_

#include "mozilla/CSSVariableDeclarations.h"
#include "mozilla/GenericSpecifiedValues.h"
#include "mozilla/RuleNodeCacheConditions.h"
#include "mozilla/SheetType.h"
#include "nsAutoPtr.h"
#include "nsCSSProps.h"
#include "nsCSSValue.h"
#include "nsStyleStructFwd.h"

class nsPresContext;
class nsStyleContext;
struct nsRuleData;

typedef void (*nsPostResolveFunc)(void* aStyleStruct, nsRuleData* aData);

struct nsRuleData final: mozilla::GenericSpecifiedValues
{
  mozilla::RuleNodeCacheConditions mConditions;
  bool mIsImportantRule;
  mozilla::SheetType mLevel;
  nsStyleContext* const mStyleContext;

  // We store nsCSSValues needed to compute the data for one or more
  // style structs (specified by the bitfield mSIDs).  These are stored
  // in a single array allocation (which our caller allocates; see
  // AutoCSSValueArray)   The offset of each property |prop| in
  // mValueStorage is the sum of
  // mValueOffsets[nsCSSProps::kSIDTable[prop]] and
  // nsCSSProps::PropertyIndexInStruct(prop).  The only place we gather
  // more than one style struct's data at a time is
  // nsRuleNode::HasAuthorSpecifiedRules; therefore some code that we
  // know is not called from HasAuthorSpecifiedRules assumes that the
  // mValueOffsets for the one struct in mSIDs is zero.
  nsCSSValue* const mValueStorage; // our user owns this array
  size_t mValueOffsets[nsStyleStructID_Length];

  nsAutoPtr<mozilla::CSSVariableDeclarations> mVariables;

  nsRuleData(uint32_t aSIDs, nsCSSValue* aValueStorage,
             nsPresContext* aContext, nsStyleContext* aStyleContext);

#ifdef DEBUG
  ~nsRuleData();
#else
  ~nsRuleData() {}
#endif

  /**
   * Return a pointer to the value object within |this| corresponding
   * to property |aProperty|.
   *
   * This function must only be called if the given property is in
   * mSIDs.
   */
  nsCSSValue* ValueFor(nsCSSPropertyID aProperty)
  {
    MOZ_ASSERT(aProperty < eCSSProperty_COUNT_no_shorthands,
               "invalid or shorthand property");

    nsStyleStructID sid = nsCSSProps::kSIDTable[aProperty];
    size_t indexInStruct = nsCSSProps::PropertyIndexInStruct(aProperty);

    // This should really be nsCachedStyleData::GetBitForSID, but we can't
    // include that here since it includes us.
    MOZ_ASSERT(mSIDs & (1 << sid),
               "calling nsRuleData::ValueFor on property not in mSIDs");
    MOZ_ASSERT(indexInStruct != size_t(-1),
               "logical property");

    return mValueStorage + mValueOffsets[sid] + indexInStruct;
  }

  const nsCSSValue* ValueFor(nsCSSPropertyID aProperty) const {
    return const_cast<nsRuleData*>(this)->ValueFor(aProperty);
  }

  /**
   * Getters like ValueFor(aProperty), but for each property by name
   * (ValueForBackgroundColor, etc.), and more efficient than ValueFor.
   * These use the names used for the property on DOM interfaces (the
   * 'method' field in nsCSSPropList.h).
   *
   * Like ValueFor(), the caller must check that the property is within
   * mSIDs.
   */
  #define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,        \
                   kwtable_, stylestruct_, stylestructoffset_, animtype_)    \
    nsCSSValue* ValueFor##method_() {                                        \
      MOZ_ASSERT(mSIDs & NS_STYLE_INHERIT_BIT(stylestruct_),                 \
                 "Calling nsRuleData::ValueFor" #method_ " without "         \
                 "NS_STYLE_INHERIT_BIT(" #stylestruct_ " in mSIDs.");        \
      nsStyleStructID sid = eStyleStruct_##stylestruct_;                     \
      size_t indexInStruct =                                                 \
        nsCSSProps::PropertyIndexInStruct(eCSSProperty_##id_);               \
      MOZ_ASSERT(indexInStruct != size_t(-1),                                \
                 "logical property");                                        \
      return mValueStorage + mValueOffsets[sid] + indexInStruct;             \
    }                                                                        \
    const nsCSSValue* ValueFor##method_() const {                            \
      return const_cast<nsRuleData*>(this)->ValueFor##method_();             \
    }
  #define CSS_PROP_LIST_EXCLUDE_LOGICAL
  #include "nsCSSPropList.h"
  #undef CSS_PROP_LIST_EXCLUDE_LOGICAL
  #undef CSS_PROP
  #undef CSS_PROP_PUBLIC_OR_PRIVATE

  // GenericSpecifiedValues overrides
  bool PropertyIsSet(nsCSSPropertyID aId) {
    return ValueFor(aId)->GetUnit() != eCSSUnit_Null;
  }

  void SetIdentStringValue(nsCSSPropertyID aId,
                           const nsString& aValue) {
    ValueFor(aId)->SetStringValue(aValue, eCSSUnit_Ident);
  }

  void SetIdentStringValueIfUnset(nsCSSPropertyID aId,
                                const nsString& aValue) {
    if (!PropertyIsSet(aId)) {
      SetIdentStringValue(aId, aValue);
    }
  }

  void SetKeywordValue(nsCSSPropertyID aId,
                       int32_t aValue) {
    ValueFor(aId)->SetIntValue(aValue, eCSSUnit_Enumerated);
  }

  void SetKeywordValueIfUnset(nsCSSPropertyID aId,
                              int32_t aValue) {
    if (!PropertyIsSet(aId)) {
      SetKeywordValue(aId, aValue);
    }
  }


  void SetIntValue(nsCSSPropertyID aId,
                   int32_t aValue) {
    ValueFor(aId)->SetIntValue(aValue, eCSSUnit_Integer);
  }

  void SetPixelValue(nsCSSPropertyID aId,
                     float aValue) {
    ValueFor(aId)->SetFloatValue(aValue, eCSSUnit_Pixel);
  }

  void SetPixelValueIfUnset(nsCSSPropertyID aId,
                            float aValue) {
    if (!PropertyIsSet(aId)) {
      SetPixelValue(aId, aValue);
    }
  }

  void SetPercentValue(nsCSSPropertyID aId,
                       float aValue) {
    ValueFor(aId)->SetPercentValue(aValue);
  }

  void SetAutoValue(nsCSSPropertyID aId) {
    ValueFor(aId)->SetAutoValue();
  }

  void SetAutoValueIfUnset(nsCSSPropertyID aId) {
    if (!PropertyIsSet(aId)) {
      SetAutoValue(aId);
    }
  }

  void SetPercentValueIfUnset(nsCSSPropertyID aId,
                              float aValue) {
    if (!PropertyIsSet(aId)) {
      SetPercentValue(aId, aValue);
    }
  }

  void SetCurrentColor(nsCSSPropertyID aId) {
    ValueFor(aId)->SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
  }

  void SetCurrentColorIfUnset(nsCSSPropertyID aId) {
    if (!PropertyIsSet(aId)) {
      SetCurrentColor(aId);
    }
  }

  void SetColorValue(nsCSSPropertyID aId,
                     nscolor aValue) {
    ValueFor(aId)->SetColorValue(aValue);
  }

  void SetColorValueIfUnset(nsCSSPropertyID aId,
                            nscolor aValue) {
    if (!PropertyIsSet(aId)) {
      SetColorValue(aId, aValue);
    }
  }

  void SetFontFamily(const nsString& aValue);
  void SetTextDecorationColorOverride();

private:
  inline size_t GetPoisonOffset();

};

#endif