MediaQueryEvaluator.cpp [plain text]
#include "config.h"
#include "MediaQueryEvaluator.h"
#include "CSSAspectRatioValue.h"
#include "CSSPrimitiveValue.h"
#include "CSSValueKeywords.h"
#include "CSSValueList.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "DOMWindow.h"
#include "FloatRect.h"
#include "Frame.h"
#include "FrameView.h"
#include "IntRect.h"
#include "MediaFeatureNames.h"
#include "MediaList.h"
#include "MediaQuery.h"
#include "MediaQueryExp.h"
#include "NodeRenderStyle.h"
#include "Page.h"
#include "PlatformScreen.h"
#include "RenderStyle.h"
#include "RenderView.h"
#include "Screen.h"
#include "Settings.h"
#include "StyleResolver.h"
#include <wtf/HashMap.h>
#if ENABLE(3D_RENDERING) && USE(ACCELERATED_COMPOSITING)
#include "RenderLayerCompositor.h"
#endif
namespace WebCore {
using namespace MediaFeatureNames;
enum MediaFeaturePrefix { MinPrefix, MaxPrefix, NoPrefix };
typedef bool (*EvalFunc)(CSSValue*, RenderStyle*, Frame*, MediaFeaturePrefix);
typedef HashMap<AtomicStringImpl*, EvalFunc> FunctionMap;
static FunctionMap* gFunctionMap;
MediaQueryEvaluator::MediaQueryEvaluator(bool mediaFeatureResult)
: m_frame(0)
, m_style(0)
, m_expResult(mediaFeatureResult)
{
}
MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, bool mediaFeatureResult)
: m_mediaType(acceptedMediaType)
, m_frame(0)
, m_style(0)
, m_expResult(mediaFeatureResult)
{
}
MediaQueryEvaluator::MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult)
: m_mediaType(acceptedMediaType)
, m_frame(0)
, m_style(0)
, m_expResult(mediaFeatureResult)
{
}
MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, Frame* frame, RenderStyle* style)
: m_mediaType(acceptedMediaType)
, m_frame(frame)
, m_style(style)
, m_expResult(false) {
}
MediaQueryEvaluator::~MediaQueryEvaluator()
{
}
bool MediaQueryEvaluator::mediaTypeMatch(const String& mediaTypeToMatch) const
{
return mediaTypeToMatch.isEmpty()
|| equalIgnoringCase(mediaTypeToMatch, "all")
|| equalIgnoringCase(mediaTypeToMatch, m_mediaType);
}
bool MediaQueryEvaluator::mediaTypeMatchSpecific(const char* mediaTypeToMatch) const
{
ASSERT(mediaTypeToMatch);
ASSERT(mediaTypeToMatch[0] != '\0');
ASSERT(!equalIgnoringCase(mediaTypeToMatch, String("all")));
return equalIgnoringCase(mediaTypeToMatch, m_mediaType);
}
static bool applyRestrictor(MediaQuery::Restrictor r, bool value)
{
return r == MediaQuery::Not ? !value : value;
}
bool MediaQueryEvaluator::eval(const MediaQuerySet* querySet, StyleResolver* styleResolver) const
{
if (!querySet)
return true;
const Vector<OwnPtr<MediaQuery> >& queries = querySet->queryVector();
if (!queries.size())
return true;
bool result = false;
for (size_t i = 0; i < queries.size() && !result; ++i) {
MediaQuery* query = queries[i].get();
if (query->ignored())
continue;
if (mediaTypeMatch(query->mediaType())) {
const Vector<OwnPtr<MediaQueryExp> >* exps = query->expressions();
size_t j = 0;
for (; j < exps->size(); ++j) {
bool exprResult = eval(exps->at(j).get());
if (styleResolver && exps->at(j)->isViewportDependent())
styleResolver->addViewportDependentMediaQueryResult(exps->at(j).get(), exprResult);
if (!exprResult)
break;
}
result = applyRestrictor(query->restrictor(), exps->size() == j);
} else
result = applyRestrictor(query->restrictor(), false);
}
return result;
}
template<typename T>
bool compareValue(T a, T b, MediaFeaturePrefix op)
{
switch (op) {
case MinPrefix:
return a >= b;
case MaxPrefix:
return a <= b;
case NoPrefix:
return a == b;
}
return false;
}
static bool compareAspectRatioValue(CSSValue* value, int width, int height, MediaFeaturePrefix op)
{
if (value->isAspectRatioValue()) {
CSSAspectRatioValue* aspectRatio = static_cast<CSSAspectRatioValue*>(value);
return compareValue(width * static_cast<int>(aspectRatio->denominatorValue()), height * static_cast<int>(aspectRatio->numeratorValue()), op);
}
return false;
}
static bool numberValue(CSSValue* value, float& result)
{
if (value->isPrimitiveValue()
&& static_cast<CSSPrimitiveValue*>(value)->isNumber()) {
result = static_cast<CSSPrimitiveValue*>(value)->getFloatValue(CSSPrimitiveValue::CSS_NUMBER);
return true;
}
return false;
}
static bool colorMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
int bitsPerComponent = screenDepthPerComponent(frame->page()->mainFrame()->view());
float number;
if (value)
return numberValue(value, number) && compareValue(bitsPerComponent, static_cast<int>(number), op);
return bitsPerComponent != 0;
}
static bool color_indexMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
{
if (!value)
return false;
float number;
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op);
}
static bool monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
{
if (!screenIsMonochrome(frame->page()->mainFrame()->view())) {
if (value) {
float number;
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op);
}
return false;
}
return colorMediaFeatureEval(value, style, frame, op);
}
static bool orientationMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
{
FrameView* view = frame->view();
if (!view)
return false;
int width = view->layoutWidth();
int height = view->layoutHeight();
if (value && value->isPrimitiveValue()) {
const int id = static_cast<CSSPrimitiveValue*>(value)->getIdent();
if (width > height) return CSSValueLandscape == id;
return CSSValuePortrait == id;
}
return height >= 0 && width >= 0;
}
static bool aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
FrameView* view = frame->view();
if (!view)
return true;
if (value)
return compareAspectRatioValue(value, view->layoutWidth(), view->layoutHeight(), op);
return true;
}
static bool device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
if (value) {
FloatRect sg = screenRect(frame->page()->mainFrame()->view());
return compareAspectRatioValue(value, static_cast<int>(sg.width()), static_cast<int>(sg.height()), op);
}
return true;
}
static bool evalResolution(CSSValue* value, Frame* frame, MediaFeaturePrefix op)
{
FrameView* view = frame->view();
if (!view)
return false;
float deviceScaleFactor = 0;
String mediaType = view->mediaType();
if (equalIgnoringCase(mediaType, "screen"))
deviceScaleFactor = frame->page()->deviceScaleFactor();
else if (equalIgnoringCase(mediaType, "print")) {
deviceScaleFactor = 3.125; }
if (!value)
return !!deviceScaleFactor;
if (!value->isPrimitiveValue())
return false;
CSSPrimitiveValue* resolution = static_cast<CSSPrimitiveValue*>(value);
return compareValue(deviceScaleFactor, resolution->isNumber() ? resolution->getFloatValue() : resolution->getFloatValue(CSSPrimitiveValue::CSS_DPPX), op);
}
static bool device_pixel_ratioMediaFeatureEval(CSSValue *value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
return (!value || static_cast<CSSPrimitiveValue*>(value)->isNumber()) && evalResolution(value, frame, op);
}
static bool resolutionMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
#if ENABLE(RESOLUTION_MEDIA_QUERY)
return (!value || static_cast<CSSPrimitiveValue*>(value)->isResolution()) && evalResolution(value, frame, op);
#else
UNUSED_PARAM(value);
UNUSED_PARAM(frame);
UNUSED_PARAM(op);
return false;
#endif
}
static bool gridMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
{
float number;
if (value && numberValue(value, number))
return compareValue(static_cast<int>(number), 0, op);
return false;
}
static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, RenderStyle* rootStyle, int& result)
{
if (!value->isPrimitiveValue())
return false;
CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
if (primitiveValue->isNumber()) {
result = primitiveValue->getIntValue();
return !strict || !result;
}
if (primitiveValue->isLength()) {
result = primitiveValue->computeLength<int>(style, rootStyle);
return true;
}
return false;
}
static bool device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
{
if (value) {
FloatRect sg = screenRect(frame->page()->mainFrame()->view());
RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
int length;
long height = sg.height();
InspectorInstrumentation::applyScreenHeightOverride(frame, &height);
return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(height), length, op);
}
return true;
}
static bool device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
{
if (value) {
FloatRect sg = screenRect(frame->page()->mainFrame()->view());
RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
int length;
long width = sg.width();
InspectorInstrumentation::applyScreenWidthOverride(frame, &width);
return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(width), length, op);
}
return true;
}
static bool heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
{
FrameView* view = frame->view();
if (!view)
return false;
if (value) {
int height = view->layoutHeight();
if (RenderView* renderView = frame->document()->renderView())
height = adjustForAbsoluteZoom(height, renderView);
RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
int length;
return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(height, length, op);
}
return view->layoutHeight() != 0;
}
static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix op)
{
FrameView* view = frame->view();
if (!view)
return false;
if (value) {
int width = view->layoutWidth();
if (RenderView* renderView = frame->document()->renderView())
width = adjustForAbsoluteZoom(width, renderView);
RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
int length;
return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(width, length, op);
}
return view->layoutWidth() != 0;
}
static bool min_colorMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return colorMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_colorMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return colorMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_color_indexMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return color_indexMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_color_indexMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return color_indexMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return monochromeMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return monochromeMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return aspect_ratioMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return aspect_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_aspect_ratioMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_device_aspect_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_aspect_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_device_pixel_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_pixel_ratioMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_device_pixel_ratioMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_pixel_ratioMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return heightMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return heightMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return widthMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return widthMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_heightMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_heightMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_widthMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return device_widthMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool min_resolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return resolutionMediaFeatureEval(value, style, frame, MinPrefix);
}
static bool max_resolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* frame, MediaFeaturePrefix)
{
return resolutionMediaFeatureEval(value, style, frame, MaxPrefix);
}
static bool animationMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
{
if (value) {
float number;
return numberValue(value, number) && compareValue(1, static_cast<int>(number), op);
}
return true;
}
static bool transitionMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
{
if (value) {
float number;
return numberValue(value, number) && compareValue(1, static_cast<int>(number), op);
}
return true;
}
static bool transform_2dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame*, MediaFeaturePrefix op)
{
if (value) {
float number;
return numberValue(value, number) && compareValue(1, static_cast<int>(number), op);
}
return true;
}
static bool transform_3dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
bool returnValueIfNoParameter;
int have3dRendering;
#if ENABLE(3D_RENDERING)
bool threeDEnabled = false;
#if USE(ACCELERATED_COMPOSITING)
if (RenderView* view = frame->contentRenderer())
threeDEnabled = view->compositor()->canRender3DTransforms();
#endif
returnValueIfNoParameter = threeDEnabled;
have3dRendering = threeDEnabled ? 1 : 0;
#else
UNUSED_PARAM(frame);
returnValueIfNoParameter = false;
have3dRendering = 0;
#endif
if (value) {
float number;
return numberValue(value, number) && compareValue(have3dRendering, static_cast<int>(number), op);
}
return returnValueIfNoParameter;
}
#if ENABLE(VIEW_MODE_CSS_MEDIA)
static bool view_modeMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
{
UNUSED_PARAM(op);
if (!value)
return true;
const int viewModeCSSKeywordID = static_cast<CSSPrimitiveValue*>(value)->getIdent();
const Page::ViewMode viewMode = frame->page()->viewMode();
bool result = false;
switch (viewMode) {
case Page::ViewModeWindowed:
result = viewModeCSSKeywordID == CSSValueWindowed;
break;
case Page::ViewModeFloating:
result = viewModeCSSKeywordID == CSSValueFloating;
break;
case Page::ViewModeFullscreen:
result = viewModeCSSKeywordID == CSSValueFullscreen;
break;
case Page::ViewModeMaximized:
result = viewModeCSSKeywordID == CSSValueMaximized;
break;
case Page::ViewModeMinimized:
result = viewModeCSSKeywordID == CSSValueMinimized;
break;
default:
result = false;
break;
}
return result;
}
#endif // ENABLE(VIEW_MODE_CSS_MEDIA)
enum PointerDeviceType { TouchPointer, MousePointer, NoPointer, UnknownPointer };
static PointerDeviceType leastCapablePrimaryPointerDeviceType(Frame* frame)
{
if (frame->settings()->deviceSupportsTouch())
return TouchPointer;
return UnknownPointer;
}
static bool hoverMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
{
PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame);
if (pointer == UnknownPointer)
return false;
float number = 1;
if (value) {
if (!numberValue(value, number))
return false;
}
return (pointer == NoPointer && !number)
|| (pointer == TouchPointer && !number)
|| (pointer == MousePointer && number == 1);
}
static bool pointerMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix)
{
PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame);
if (pointer == UnknownPointer)
return false;
if (!value)
return pointer != NoPointer;
if (!value->isPrimitiveValue())
return false;
const int id = static_cast<CSSPrimitiveValue*>(value)->getIdent();
return (pointer == NoPointer && id == CSSValueNone)
|| (pointer == TouchPointer && id == CSSValueCoarse)
|| (pointer == MousePointer && id == CSSValueFine);
}
static void createFunctionMap()
{
gFunctionMap = new FunctionMap;
#define ADD_TO_FUNCTIONMAP(name, str) \
gFunctionMap->set(name##MediaFeature.impl(), name##MediaFeatureEval);
CSS_MEDIAQUERY_NAMES_FOR_EACH_MEDIAFEATURE(ADD_TO_FUNCTIONMAP);
#undef ADD_TO_FUNCTIONMAP
}
bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const
{
if (!m_frame || !m_frame->view() || !m_style)
return m_expResult;
if (!expr->isValid())
return false;
if (!gFunctionMap)
createFunctionMap();
EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl());
if (func)
return func(expr->value(), m_style.get(), m_frame, NoPrefix);
return false;
}
}