mq.h

Go to the documentation of this file.

/*
 * This file is part of LibCSS
 * Licensed under the MIT License,
 *                http://www.opensource.org/licenses/mit-license.php
 *
 * Copyright 2018 Michael Drake <tlsa@netsurf-browser.org>
 */
 
#ifndef css_select_mq_h_
#define css_select_mq_h_
 
#include "select/helpers.h"
#include "select/strings.h"
#include "select/unit.h"
 
static inline bool mq_match_feature_range_length_op1(
                css_mq_feature_op op,
                const css_mq_value *value,
                const css_fixed client_len,
                const css_unit_ctx *unit_ctx)
{
        css_fixed v;
 
        if (value->type != CSS_MQ_VALUE_TYPE_DIM) {
                return false;
        }
 
        if (value->data.dim.unit != UNIT_PX) {
                v = css_unit_len2px_mq(unit_ctx,
                                value->data.dim.len,
                                css__to_css_unit(value->data.dim.unit));
        } else {
                v = value->data.dim.len;
        }
 
        switch (op) {
        case CSS_MQ_FEATURE_OP_BOOL: return false;
        case CSS_MQ_FEATURE_OP_LT:   return v <  client_len;
        case CSS_MQ_FEATURE_OP_LTE:  return v <= client_len;
        case CSS_MQ_FEATURE_OP_EQ:   return v == client_len;
        case CSS_MQ_FEATURE_OP_GTE:  return v >= client_len;
        case CSS_MQ_FEATURE_OP_GT:   return v >  client_len;
        default:
                return false;
        }
}
 
static inline bool mq_match_feature_range_length_op2(
                css_mq_feature_op op,
                const css_mq_value *value,
                const css_fixed client_len,
                const css_unit_ctx *unit_ctx)
{
        css_fixed v;
 
        if (op == CSS_MQ_FEATURE_OP_UNUSED) {
                return true;
        }
        if (value->type != CSS_MQ_VALUE_TYPE_DIM) {
                return false;
        }
 
        if (value->data.dim.unit != UNIT_PX) {
                v = css_unit_len2px_mq(unit_ctx,
                                value->data.dim.len,
                                css__to_css_unit(value->data.dim.unit));
        } else {
                v = value->data.dim.len;
        }
 
        switch (op) {
        case CSS_MQ_FEATURE_OP_LT:  return client_len <  v;
        case CSS_MQ_FEATURE_OP_LTE: return client_len <= v;
        case CSS_MQ_FEATURE_OP_EQ:  return client_len == v;
        case CSS_MQ_FEATURE_OP_GTE: return client_len >= v;
        case CSS_MQ_FEATURE_OP_GT:  return client_len >  v;
        default:
                return false;
        }
}
 
static inline bool mq_match_feature_eq_ident_op1(
                css_mq_feature_op op,
                const css_mq_value *value,
                const lwc_string *client_value)
{
        bool is_match;
 
        if (value->type != CSS_MQ_VALUE_TYPE_IDENT) {
                return false;
        }
 
        if (value->data.ident == NULL || client_value == NULL) {
                return false;
        }
 
        switch (op) {
        case CSS_MQ_FEATURE_OP_EQ:
                return (lwc_string_isequal(value->data.ident,
                                client_value, &is_match) == lwc_error_ok) &&
                                is_match;
        default:
                return false;
        }
}
 
static inline bool mq_match_feature(
                const css_mq_feature *feat,
                const css_unit_ctx *unit_ctx,
                const css_media *media,
                const css_select_strings *str)
{
        bool match;
 
        /* TODO: Use interned string for comparison. */
        if (lwc_string_isequal(feat->name,
                        str->width, &match) == lwc_error_ok &&
                        match == true) {
                if (!mq_match_feature_range_length_op1(feat->op, &feat->value,
                                        media->width, unit_ctx)) {
                        return false;
                }
                return mq_match_feature_range_length_op2(feat->op2,
                                &feat->value2, media->width, unit_ctx);
 
        } else if (lwc_string_isequal(feat->name,
                        str->height, &match) == lwc_error_ok &&
                        match == true) {
                if (!mq_match_feature_range_length_op1(feat->op, &feat->value,
                                media->height, unit_ctx)) {
                        return false;
                }
 
                return mq_match_feature_range_length_op2(feat->op2,
                                &feat->value2, media->height, unit_ctx);
 
        } else if (lwc_string_isequal(feat->name,
                        str->prefers_color_scheme, &match) == lwc_error_ok &&
                        match == true) {
                if (mq_match_feature_eq_ident_op1(feat->op, &feat->value,
                                media->prefers_color_scheme) ||
                    feat->op == CSS_MQ_FEATURE_OP_BOOL) {
                        return true;
                }
 
                return false;
        }
 
        /* TODO: Look at other feature names. */
 
        return false;
}
 
static inline bool mq_match_condition(
                const css_mq_cond *cond,
                const css_unit_ctx *unit_ctx,
                const css_media *media,
                const css_select_strings *str)
{
        bool matched = !cond->op;
 
        for (uint32_t i = 0; i < cond->nparts; i++) {
                bool part_matched;
                if (cond->parts[i]->type == CSS_MQ_FEATURE) {
                        part_matched = mq_match_feature(
                                        cond->parts[i]->data.feat,
                                        unit_ctx, media, str);
                } else {
                        assert(cond->parts[i]->type == CSS_MQ_COND);
                        part_matched = mq_match_condition(
                                        cond->parts[i]->data.cond,
                                        unit_ctx, media, str);
                }
 
                if (cond->op) {
                        /* OR */
                        matched |= part_matched;
                        if (matched) {
                                break; /* Short-circuit */
                        }
                } else {
                        /* AND */
                        matched &= part_matched;
                        if (!matched) {
                                break; /* Short-circuit */
                        }
                }
        }
 
        return matched != cond->negate;
}
 
static inline bool mq__list_match(
                const css_mq_query *m,
                const css_unit_ctx *unit_ctx,
                const css_media *media,
                const css_select_strings *str)
{
        for (; m != NULL; m = m->next) {
                /* Check type */
                if (!!(m->type & media->type) != m->negate_type) {
                        if (m->cond == NULL ||
                                        mq_match_condition(m->cond,
                                                        unit_ctx, media, str)) {
                                /* We have a match, no need to look further. */
                                return true;
                        }
                }
        }
 
        return false;
}
 
static inline bool mq_rule_good_for_media(
                const css_rule *rule,
                const css_unit_ctx *unit_ctx,
                const css_media *media,
                const css_select_strings *str)
{
        bool applies = true;
        const css_rule *ancestor = rule;
 
        while (ancestor != NULL) {
                const css_rule_media *m = (const css_rule_media *) ancestor;
 
                if (ancestor->type == CSS_RULE_MEDIA) {
                        applies = mq__list_match(m->media,
                                        unit_ctx, media, str);
                        if (applies == false) {
                                break;
                        }
                }
 
                if (ancestor->ptype != CSS_RULE_PARENT_STYLESHEET) {
                        ancestor = ancestor->parent;
                } else {
                        ancestor = NULL;
                }
        }
 
        return applies;
}
 
#endif