gfx/src/FontPropertyTypes.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* font specific types shared by both thebes and layout */
   7
   8 #ifndef GFX_FONT_PROPERTY_TYPES_H
   9 #define GFX_FONT_PROPERTY_TYPES_H
  10
  11 #include <algorithm>
  12 #include <cstdint>
  13 #include <cmath>
  14 #include <utility>
  15
  16 #include <ctype.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include "mozilla/Assertions.h"
  21 #include "mozilla/ServoStyleConsts.h"
  22 #include "nsString.h"
  23
  24 /*
  25  * This file is separate from gfxFont.h so that layout can include it
  26  * without bringing in gfxFont.h and everything it includes.
  27  */
  28
  29 namespace mozilla {
  30
  31 using FontSlantStyle = StyleFontStyle;
  32 using FontWeight = StyleFontWeight;
  33 using FontStretch = StyleFontStretch;
  34
  35 /**
  36  * Convenience type to hold a <min, max> pair representing a range of values.
  37  *
  38  * The min and max are both inclusive, so when min == max the range represents
  39  * a single value (not an empty range).
  40  */
  41 template <class T, class Derived>
  42 class FontPropertyRange {
  43   // This implementation assumes the underlying property type is a 16-bit value
  44   // (see FromScalar and AsScalar below).
  45   static_assert(sizeof(T) == 2, "FontPropertyValue should be a 16-bit type!");
  46
  47  public:
  48   /**
  49    * Construct a range from given minimum and maximum values (inclusive).
  50    */
  51   FontPropertyRange(T aMin, T aMax) : mValues(aMin, aMax) {
  52     MOZ_ASSERT(aMin <= aMax);
  53   }
  54
  55   /**
  56    * Construct a range representing a single value (min==max).
  57    */
  58   explicit FontPropertyRange(T aValue) : mValues(aValue, aValue) {}
  59
  60   explicit FontPropertyRange(const FontPropertyRange& aOther) = default;
  61   FontPropertyRange& operator=(const FontPropertyRange& aOther) = default;
  62
  63   T Min() const { return mValues.first; }
  64   T Max() const { return mValues.second; }
  65
  66   /**
  67    * Clamp the given value to this range.
  68    *
  69    * (We can't use mozilla::Clamp here because it only accepts integral types.)
  70    */
  71   T Clamp(T aValue) const {
  72     return aValue <= Min() ? Min() : (aValue >= Max() ? Max() : aValue);
  73   }
  74
  75   /**
  76    * Return whether the range consists of a single unique value.
  77    */
  78   bool IsSingle() const { return Min() == Max(); }
  79
  80   bool operator==(const FontPropertyRange& aOther) const {
  81     return mValues == aOther.mValues;
  82   }
  83   bool operator!=(const FontPropertyRange& aOther) const {
  84     return mValues != aOther.mValues;
  85   }
  86
  87   /**
  88    * Conversion of the property range to/from a single 32-bit scalar value,
  89    * suitable for IPC serialization, hashing, caching.
  90    *
  91    * No assumptions should be made about the numeric value of the scalar.
  92    *
  93    * This depends on the underlying property type being a 16-bit value!
  94    */
  95   using ScalarType = uint32_t;
  96
  97   ScalarType AsScalar() const {
  98     return (mValues.first.UnsignedRaw() << 16) | mValues.second.UnsignedRaw();
  99   }
 100
 101   static Derived FromScalar(ScalarType aScalar) {
 102     static_assert(std::is_base_of_v<FontPropertyRange, Derived>);
 103     return Derived(T::FromRaw(aScalar >> 16), T::FromRaw(aScalar & 0xffff));
 104   }
 105
 106  protected:
 107   std::pair<T, T> mValues;
 108 };
 109
 110 class WeightRange : public FontPropertyRange<FontWeight, WeightRange> {
 111  public:
 112   WeightRange(FontWeight aMin, FontWeight aMax)
 113       : FontPropertyRange(aMin, aMax) {}
 114
 115   explicit WeightRange(FontWeight aWeight) : FontPropertyRange(aWeight) {}
 116
 117   WeightRange(const WeightRange& aOther) = default;
 118
 119   void ToString(nsACString& aOutString, const char* aDelim = "..") const {
 120     aOutString.AppendFloat(Min().ToFloat());
 121     if (!IsSingle()) {
 122       aOutString.Append(aDelim);
 123       aOutString.AppendFloat(Max().ToFloat());
 124     }
 125   }
 126 };
 127
 128 class StretchRange : public FontPropertyRange<FontStretch, StretchRange> {
 129  public:
 130   StretchRange(FontStretch aMin, FontStretch aMax)
 131       : FontPropertyRange(aMin, aMax) {}
 132
 133   explicit StretchRange(FontStretch aStretch) : FontPropertyRange(aStretch) {}
 134
 135   StretchRange(const StretchRange& aOther) = default;
 136
 137   void ToString(nsACString& aOutString, const char* aDelim = "..") const {
 138     aOutString.AppendFloat(Min().ToFloat());
 139     if (!IsSingle()) {
 140       aOutString.Append(aDelim);
 141       aOutString.AppendFloat(Max().ToFloat());
 142     }
 143   }
 144 };
 145
 146 class SlantStyleRange
 147     : public FontPropertyRange<FontSlantStyle, SlantStyleRange> {
 148  public:
 149   SlantStyleRange(FontSlantStyle aMin, FontSlantStyle aMax)
 150       : FontPropertyRange(aMin, aMax) {}
 151
 152   explicit SlantStyleRange(FontSlantStyle aStyle) : FontPropertyRange(aStyle) {}
 153
 154   SlantStyleRange(const SlantStyleRange& aOther) = default;
 155
 156   void ToString(nsACString& aOutString, const char* aDelim = "..") const {
 157     Min().ToString(aOutString);
 158     if (!IsSingle()) {
 159       aOutString.Append(aDelim);
 160       Max().ToString(aOutString);
 161     }
 162   }
 163 };
 164
 165 }  // namespace mozilla
 166
 167 #endif  // GFX_FONT_PROPERTY_TYPES_H