src/plugins/litehtml_viewer/litehtml/media_query.cpp

   1 #include "html.h"
   2 #include "media_query.h"
   3 #include "document.h"
   4
   5
   6 litehtml::media_query::media_query()
   7 {
   8         m_media_type    = media_type_all;
   9         m_not                   = false;
  10 }
  11
  12 litehtml::media_query::media_query( const media_query& val )
  13 {
  14         m_not                   = val.m_not;
  15         m_expressions   = val.m_expressions;
  16         m_media_type    = val.m_media_type;
  17 }
  18
  19 litehtml::media_query::ptr litehtml::media_query::create_from_string(const string& str, const std::shared_ptr<document>& doc)
  20 {
  21         media_query::ptr query = std::make_shared<media_query>();
  22
  23         string_vector tokens;
  24         split_string(str, tokens, " \t\r\n", "", "(");
  25
  26         for(auto & token : tokens)
  27         {
  28                 if(token == "not")
  29                 {
  30                         query->m_not = true;
  31                 } else if(token.at(0) == '(')
  32                 {
  33                         token.erase(0, 1);
  34                         if(!token.empty() && token.at(token.length() - 1) == ')')
  35                         {
  36                                 token.erase(token.length() - 1, 1);
  37                         }
  38                         media_query_expression expr;
  39                         string_vector expr_tokens;
  40                         split_string(token, expr_tokens, ":");
  41                         if(!expr_tokens.empty())
  42                         {
  43                                 trim(expr_tokens[0]);
  44                                 expr.feature = (media_feature) value_index(expr_tokens[0], media_feature_strings, media_feature_none);
  45                                 if(expr.feature != media_feature_none)
  46                                 {
  47                                         if(expr_tokens.size() == 1)
  48                                         {
  49                                                 expr.check_as_bool = true;
  50                                         } else
  51                                         {
  52                                                 trim(expr_tokens[1]);
  53                                                 expr.check_as_bool = false;
  54                                                 if(expr.feature == media_feature_orientation)
  55                                                 {
  56                                                         expr.val = value_index(expr_tokens[1], media_orientation_strings, media_orientation_landscape);
  57                                                 } else
  58                                                 {
  59                                                         string::size_type slash_pos = expr_tokens[1].find('/');
  60                                                         if( slash_pos != string::npos )
  61                                                         {
  62                                                                 string val1 = expr_tokens[1].substr(0, slash_pos);
  63                                                                 string val2 = expr_tokens[1].substr(slash_pos + 1);
  64                                                                 trim(val1);
  65                                                                 trim(val2);
  66                                                                 expr.val = atoi(val1.c_str());
  67                                                                 expr.val2 = atoi(val2.c_str());
  68                                                         } else
  69                                                         {
  70                                                                 css_length length;
  71                                                                 length.fromString(expr_tokens[1]);
  72                                                                 if(length.units() == css_units_dpcm || length.units() == css_units_dpi)
  73                                                                 {
  74                                                                         expr.val = (int) (length.val() * 2.54);
  75                                                                 } else
  76                                                                 {
  77                                                                         if(doc)
  78                                                                         {
  79                                                                                 doc->cvt_units(length, doc->container()->get_default_font_size());
  80                                                                         }
  81                                                                         expr.val = (int) length.val();
  82                                                                 }
  83                                                         }
  84                                                 }
  85                                         }
  86                                         query->m_expressions.push_back(expr);
  87                                 }
  88                         }
  89                 } else
  90                 {
  91                         query->m_media_type = (media_type) value_index(token, media_type_strings, media_type_none);
  92                 }
  93         }
  94
  95         return query;
  96 }
  97
  98 bool litehtml::media_query::check( const media_features& features ) const
  99 {
 100         bool res = false;
 101         if(m_media_type == media_type_all || m_media_type == features.type)
 102         {
 103                 res = true;
 104                 for(auto expression : m_expressions)
 105                 {
 106                         if(!expression.check(features))
 107                         {
 108                                 res = false;
 109                 break;
 110                         }
 111                 }
 112         }
 113
 114         if(m_not)
 115         {
 116                 res = !res;
 117         }
 118
 119         return res;
 120 }
 121
 122 //////////////////////////////////////////////////////////////////////////
 123
 124 litehtml::media_query_list::ptr litehtml::media_query_list::create_from_string(const string& str, const std::shared_ptr<document>& doc)
 125 {
 126         media_query_list::ptr list = std::make_shared<media_query_list>();
 127
 128         string_vector tokens;
 129         split_string(str, tokens, ",");
 130
 131         for(auto & token : tokens)
 132         {
 133                 trim(token);
 134                 lcase(token);
 135
 136                 litehtml::media_query::ptr query = media_query::create_from_string(token, doc);
 137                 if(query)
 138                 {
 139                         list->m_queries.push_back(query);
 140                 }
 141         }
 142         if(list->m_queries.empty())
 143         {
 144                 list = nullptr;
 145         }
 146
 147         return list;
 148 }
 149
 150 bool litehtml::media_query_list::apply_media_features( const media_features& features )
 151 {
 152         bool apply = false;
 153
 154         for(auto & query : m_queries)
 155         {
 156                 if(query->check(features))
 157                 {
 158                         apply = true;
 159             break;
 160                 }
 161         }
 162
 163         bool ret = (apply != m_is_used);
 164         m_is_used = apply;
 165         return ret;
 166 }
 167
 168 bool litehtml::media_query_expression::check( const media_features& features ) const
 169 {
 170         switch(feature)
 171         {
 172         case media_feature_width:
 173                 if(check_as_bool)
 174                 {
 175                         return (features.width != 0);
 176                 } else if(features.width == val)
 177                 {
 178                         return true;
 179                 }
 180                 break;
 181         case media_feature_min_width:
 182                 if(features.width >= val)
 183                 {
 184                         return true;
 185                 }
 186                 break;
 187         case media_feature_max_width:
 188                 if(features.width <= val)
 189                 {
 190                         return true;
 191                 }
 192                 break;
 193         case media_feature_height:
 194                 if(check_as_bool)
 195                 {
 196                         return (features.height != 0);
 197                 } else if(features.height == val)
 198                 {
 199                         return true;
 200                 }
 201                 break;
 202         case media_feature_min_height:
 203                 if(features.height >= val)
 204                 {
 205                         return true;
 206                 }
 207                 break;
 208         case media_feature_max_height:
 209                 if(features.height <= val)
 210                 {
 211                         return true;
 212                 }
 213                 break;
 214
 215         case media_feature_device_width:
 216                 if(check_as_bool)
 217                 {
 218                         return (features.device_width != 0);
 219                 } else if(features.device_width == val)
 220                 {
 221                         return true;
 222                 }
 223                 break;
 224         case media_feature_min_device_width:
 225                 if(features.device_width >= val)
 226                 {
 227                         return true;
 228                 }
 229                 break;
 230         case media_feature_max_device_width:
 231                 if(features.device_width <= val)
 232                 {
 233                         return true;
 234                 }
 235                 break;
 236         case media_feature_device_height:
 237                 if(check_as_bool)
 238                 {
 239                         return (features.device_height != 0);
 240                 } else if(features.device_height == val)
 241                 {
 242                         return true;
 243                 }
 244                 break;
 245         case media_feature_min_device_height:
 246                 if(features.device_height >= val)
 247                 {
 248                         return true;
 249                 }
 250                 break;
 251         case media_feature_max_device_height:
 252                 if(features.device_height <= val)
 253                 {
 254                         return true;
 255                 }
 256                 break;
 257
 258         case media_feature_orientation:
 259                 if(features.height >= features.width)
 260                 {
 261                         if(val == media_orientation_portrait)
 262                         {
 263                                 return true;
 264                         }
 265                 } else
 266                 {
 267                         if(val == media_orientation_landscape)
 268                         {
 269                                 return true;
 270                         }
 271                 }
 272                 break;
 273         case media_feature_aspect_ratio:
 274                 if(features.height && val2)
 275                 {
 276                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 277                         int ratio_feat = round_d( (double) features.width / (double) features.height * 100.0 );
 278                         if(ratio_this == ratio_feat)
 279                         {
 280                                 return true;
 281                         }
 282                 }
 283                 break;
 284         case media_feature_min_aspect_ratio:
 285                 if(features.height && val2)
 286                 {
 287                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 288                         int ratio_feat = round_d( (double) features.width / (double) features.height * 100.0 );
 289                         if(ratio_feat >= ratio_this)
 290                         {
 291                                 return true;
 292                         }
 293                 }
 294                 break;
 295         case media_feature_max_aspect_ratio:
 296                 if(features.height && val2)
 297                 {
 298                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 299                         int ratio_feat = round_d( (double) features.width / (double) features.height * 100.0 );
 300                         if(ratio_feat <= ratio_this)
 301                         {
 302                                 return true;
 303                         }
 304                 }
 305                 break;
 306
 307         case media_feature_device_aspect_ratio:
 308                 if(features.device_height && val2)
 309                 {
 310                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 311                         int ratio_feat = round_d( (double) features.device_width / (double) features.device_height * 100.0 );
 312                         if(ratio_feat == ratio_this)
 313                         {
 314                                 return true;
 315                         }
 316                 }
 317                 break;
 318         case media_feature_min_device_aspect_ratio:
 319                 if(features.device_height && val2)
 320                 {
 321                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 322                         int ratio_feat = round_d( (double) features.device_width / (double) features.device_height * 100.0 );
 323                         if(ratio_feat >= ratio_this)
 324                         {
 325                                 return true;
 326                         }
 327                 }
 328                 break;
 329         case media_feature_max_device_aspect_ratio:
 330                 if(features.device_height && val2)
 331                 {
 332                         int ratio_this = round_d( (double) val / (double) val2 * 100 );
 333                         int ratio_feat = round_d( (double) features.device_width / (double) features.device_height * 100.0 );
 334                         if(ratio_feat <= ratio_this)
 335                         {
 336                                 return true;
 337                         }
 338                 }
 339                 break;
 340
 341         case media_feature_color:
 342                 if(check_as_bool)
 343                 {
 344                         return (features.color != 0);
 345                 } else if(features.color == val)
 346                 {
 347                         return true;
 348                 }
 349                 break;
 350         case media_feature_min_color:
 351                 if(features.color >= val)
 352                 {
 353                         return true;
 354                 }
 355                 break;
 356         case media_feature_max_color:
 357                 if(features.color <= val)
 358                 {
 359                         return true;
 360                 }
 361                 break;
 362
 363         case media_feature_color_index:
 364                 if(check_as_bool)
 365                 {
 366                         return (features.color_index != 0);
 367                 } else if(features.color_index == val)
 368                 {
 369                         return true;
 370                 }
 371                 break;
 372         case media_feature_min_color_index:
 373                 if(features.color_index >= val)
 374                 {
 375                         return true;
 376                 }
 377                 break;
 378         case media_feature_max_color_index:
 379                 if(features.color_index <= val)
 380                 {
 381                         return true;
 382                 }
 383                 break;
 384
 385         case media_feature_monochrome:
 386                 if(check_as_bool)
 387                 {
 388                         return (features.monochrome != 0);
 389                 } else if(features.monochrome == val)
 390                 {
 391                         return true;
 392                 }
 393                 break;
 394         case media_feature_min_monochrome:
 395                 if(features.monochrome >= val)
 396                 {
 397                         return true;
 398                 }
 399                 break;
 400         case media_feature_max_monochrome:
 401                 if(features.monochrome <= val)
 402                 {
 403                         return true;
 404                 }
 405                 break;
 406
 407         case media_feature_resolution:
 408                 if(features.resolution == val)
 409                 {
 410                         return true;
 411                 }
 412                 break;
 413         case media_feature_min_resolution:
 414                 if(features.resolution >= val)
 415                 {
 416                         return true;
 417                 }
 418                 break;
 419         case media_feature_max_resolution:
 420                 if(features.resolution <= val)
 421                 {
 422                         return true;
 423                 }
 424                 break;
 425         default:
 426                 return false;
 427         }
 428
 429         return false;
 430 }