static bool colorMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
float number;
int bitsPerComponent = mediaValues.colorBitsPerComponent();
if (value.isValid())
return numberValue(value, number) && compareValue(bitsPerComponent, static_cast<int>(number), op);
return bitsPerComponent != 0;
}
static bool aspectRatioMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
if (value.isValid())
return compareAspectRatioValue(value, mediaValues.viewportWidth(), mediaValues.viewportHeight(), op);
// ({,min-,max-}aspect-ratio)
// assume if we have a device, its aspect ratio is non-zero.
return true;
}
static bool gridMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues&)
{
// if output device is bitmap, grid: 0 == true
// assume we have bitmap device
float number;
if (value.isValid() && numberValue(value, number))
return compareValue(static_cast<int>(number), 0, op);
return false;
}
static bool deviceWidthMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
if (value.isValid())
return computeLengthAndCompare(value, op, mediaValues, mediaValues.deviceWidth());
// ({,min-,max-}device-width)
// assume if we have a device, assume non-zero
return true;
}
static bool heightMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
int height = mediaValues.viewportHeight();
if (value.isValid()) {
int length;
return computeLength(value, mediaValues, length) && compareValue(height, length, op);
}
return height;
}
static bool widthMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
int width = mediaValues.viewportWidth();
if (value.isValid()) {
int length;
return computeLength(value, mediaValues, length) && compareValue(width, length, op);
}
return width;
}
static bool deviceWidthMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
if (value.isValid()) {
int length;
return computeLength(value, mediaValues, length) && compareValue(static_cast<int>(mediaValues.deviceWidth()), length, op);
}
// ({,min-,max-}device-width)
// assume if we have a device, assume non-zero
return true;
}
static bool colorIndexMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues&)
{
// FIXME: We currently assume that we do not support indexed displays, as it is unknown
// how to retrieve the information if the display mode is indexed. This matches Firefox.
if (!value.isValid())
return false;
// Acording to spec, if the device does not use a color lookup table, the value is zero.
float number;
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op);
}
static bool monochromeMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
if (!mediaValues.monochromeBitsPerComponent()) {
if (value.isValid()) {
float number;
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op);
}
return false;
}
return colorMediaFeatureEval(value, op, mediaValues);
}
static bool hoverMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
HoverType hover = mediaValues.primaryHoverType();
if (!value.isValid())
return hover != HoverTypeNone;
if (!value.isID)
return false;
return (hover == HoverTypeNone && value.id == CSSValueNone)
|| (hover == HoverTypeOnDemand && value.id == CSSValueOnDemand)
|| (hover == HoverTypeHover && value.id == CSSValueHover);
}
static bool pointerMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
PointerType pointer = mediaValues.primaryPointerType();
if (!value.isValid())
return pointer != PointerTypeNone;
if (!value.isID)
return false;
return (pointer == PointerTypeNone && value.id == CSSValueNone)
|| (pointer == PointerTypeCoarse && value.id == CSSValueCoarse)
|| (pointer == PointerTypeFine && value.id == CSSValueFine);
}
static bool scanMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
if (!mediaValues.scanMediaType())
return false;
if (!value.isValid())
return true;
if (!value.isID)
return false;
// If a platform interface supplies progressive/interlace info for TVs in the
// future, it needs to be handled here. For now, assume a modern TV with
// progressive display.
return (value.id == CSSValueProgressive);
}
static bool evalResolution(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
// According to MQ4, only 'screen', 'print' and 'speech' may match.
// FIXME: What should speech match? https://www.w3.org/Style/CSS/Tracker/issues/348
float actualResolution = 0;
// This checks the actual media type applied to the document, and we know
// this method only got called if this media type matches the one defined
// in the query. Thus, if if the document's media type is "print", the
// media type of the query will either be "print" or "all".
if (mediaValues.screenMediaType()) {
actualResolution = clampTo<float>(mediaValues.devicePixelRatio());
} else if (mediaValues.printMediaType()) {
// The resolution of images while printing should not depend on the DPI
// of the screen. Until we support proper ways of querying this info
// we use 300px which is considered minimum for current printers.
actualResolution = 300 / cssPixelsPerInch;
}
if (!value.isValid())
return !!actualResolution;
if (!value.isValue)
return false;
if (value.unit == CSSPrimitiveValue::CSS_NUMBER)
return compareValue(actualResolution, clampTo<float>(value.value), op);
if (!CSSPrimitiveValue::isResolution(value.unit))
return false;
double canonicalFactor = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(value.unit);
double dppxFactor = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(CSSPrimitiveValue::CSS_DPPX);
float valueInDppx = clampTo<float>(value.value * (canonicalFactor / dppxFactor));
if (CSSPrimitiveValue::isDotsPerCentimeter(value.unit)) {
// To match DPCM to DPPX values, we limit to 2 decimal points.
// The http://dev.w3.org/csswg/css3-values/#absolute-lengths recommends
// "that the pixel unit refer to the whole number of device pixels that best
// approximates the reference pixel". With that in mind, allowing 2 decimal
// point precision seems appropriate.
return compareValue(
floorf(0.5 + 100 * actualResolution) / 100,
floorf(0.5 + 100 * valueInDppx) / 100, op);
}
return compareValue(actualResolution, valueInDppx, op);
}
static bool transform3dMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
UseCounter::count(mediaValues.document(), UseCounter::PrefixedTransform3dMediaFeature);
bool returnValueIfNoParameter;
int have3dRendering;
bool threeDEnabled = mediaValues.threeDEnabled();
returnValueIfNoParameter = threeDEnabled;
have3dRendering = threeDEnabled ? 1 : 0;
if (value.isValid()) {
float number;
return numberValue(value, number) && compareValue(have3dRendering, static_cast<int>(number), op);
}
return returnValueIfNoParameter;
}
static bool pointerMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
MediaValues::PointerDeviceType pointer = mediaValues.pointer();
// If we're on a port that hasn't explicitly opted into providing pointer device information
// (or otherwise can't be confident in the pointer hardware available), then behave exactly
// as if this feature feature isn't supported.
if (pointer == MediaValues::UnknownPointer)
return false;
if (!value.isValid())
return pointer != MediaValues::NoPointer;
if (!value.isID)
return false;
return (pointer == MediaValues::NoPointer && value.id == CSSValueNone)
|| (pointer == MediaValues::TouchPointer && value.id == CSSValueCoarse)
|| (pointer == MediaValues::MousePointer && value.id == CSSValueFine);
}
static bool hoverMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
MediaValues::PointerDeviceType pointer = mediaValues.pointer();
// If we're on a port that hasn't explicitly opted into providing pointer device information
// (or otherwise can't be confident in the pointer hardware available), then behave exactly
// as if this feature feature isn't supported.
if (pointer == MediaValues::UnknownPointer)
return false;
float number = 1;
if (value.isValid()) {
if (!numberValue(value, number))
return false;
}
return (pointer == MediaValues::NoPointer && !number)
|| (pointer == MediaValues::TouchPointer && !number)
|| (pointer == MediaValues::MousePointer && number == 1);
}
static bool anyHoverMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
int availableHoverTypes = mediaValues.availableHoverTypes();
if (!value.isValid())
return availableHoverTypes & ~HoverTypeNone;
if (!value.isID)
return false;
switch (value.id) {
case CSSValueNone:
return availableHoverTypes & HoverTypeNone;
case CSSValueOnDemand:
return availableHoverTypes & HoverTypeOnDemand;
case CSSValueHover:
return availableHoverTypes & HoverTypeHover;
default:
ASSERT_NOT_REACHED();
return false;
}
}
static bool anyPointerMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix, const MediaValues& mediaValues)
{
int availablePointers = mediaValues.availablePointerTypes();
if (!value.isValid())
return availablePointers & ~PointerTypeNone;
if (!value.isID)
return false;
switch (value.id) {
case CSSValueCoarse:
return availablePointers & PointerTypeCoarse;
case CSSValueFine:
return availablePointers & PointerTypeFine;
case CSSValueNone:
return availablePointers & PointerTypeNone;
default:
ASSERT_NOT_REACHED();
return false;
}
}
static bool devicePixelRatioMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& mediaValues)
{
UseCounter::count(mediaValues.document(), UseCounter::PrefixedDevicePixelRatioMediaFeature);
return (!value.isValid() || value.unit == CSSPrimitiveValue::CSS_NUMBER) && evalResolution(value, op, mediaValues);
}
static bool resolutionMediaFeatureEval(const MediaQueryExpValue& value, MediaFeaturePrefix op, const MediaValues& MediaValues)
{
return (!value.isValid() || CSSPrimitiveValue::isResolution(value.unit)) && evalResolution(value, op, MediaValues);
}
