src/plugins/litehtml_viewer/litehtml/css_selector.cpp

   1 #include "html.h"
   2 #include "css_selector.h"
   3 #include "document.h"
   4
   5 void litehtml::css_element_selector::parse_nth_child_params(const string& param, int& num, int& off)
   6 {
   7         if (param == "odd")
   8         {
   9                 num = 2;
  10                 off = 1;
  11         }
  12         else if (param == "even")
  13         {
  14                 num = 2;
  15                 off = 0;
  16         }
  17         else
  18         {
  19                 string_vector tokens;
  20                 split_string(param, tokens, " n", "n");
  21
  22                 string s_num;
  23                 string s_off;
  24
  25                 string s_int;
  26                 for (const auto& token : tokens)
  27                 {
  28                         if (token == "n")
  29                         {
  30                                 s_num = s_int;
  31                                 s_int.clear();
  32                         }
  33                         else
  34                         {
  35                                 s_int += token;
  36                         }
  37                 }
  38                 s_off = s_int;
  39
  40                 num = atoi(s_num.c_str());
  41                 off = atoi(s_off.c_str());
  42         }
  43 }
  44
  45 void litehtml::css_element_selector::parse( const string& txt )
  46 {
  47         string::size_type el_end = txt.find_first_of(".#[:");
  48         string tag = txt.substr(0, el_end);
  49         litehtml::lcase(tag);
  50         if (tag == "") tag = "*";
  51         m_tag = _id(tag);
  52
  53         m_attrs.clear();
  54         while(el_end != string::npos)
  55         {
  56                 if(txt[el_end] == '.')
  57                 {
  58                         css_attribute_selector attribute;
  59
  60                         attribute.type = select_class;
  61                         string::size_type pos = txt.find_first_of(".#[:", el_end + 1);
  62                         string name             = txt.substr(el_end + 1, pos - el_end - 1);
  63                         litehtml::lcase(name);
  64                         attribute.name = _id(name);
  65                         m_attrs.push_back(attribute);
  66                         el_end = pos;
  67                 } else if(txt[el_end] == '#')
  68                 {
  69                         css_attribute_selector attribute;
  70
  71                         attribute.type = select_id;
  72                         string::size_type pos = txt.find_first_of(".#[:", el_end + 1);
  73                         string name             = txt.substr(el_end + 1, pos - el_end - 1);
  74                         litehtml::lcase(name);
  75                         attribute.name = _id(name);
  76                         m_attrs.push_back(attribute);
  77                         el_end = pos;
  78                 } else if(txt[el_end] == ':')
  79                 {
  80                         css_attribute_selector attribute;
  81
  82                         if(txt[el_end + 1] == ':')
  83                         {
  84                                 attribute.type = select_pseudo_element;
  85                                 string::size_type pos = txt.find_first_of(".#[:", el_end + 2);
  86                                 string name             = txt.substr(el_end + 2, pos - el_end - 2);
  87                                 litehtml::lcase(name);
  88                                 attribute.name = _id(name);
  89                                 m_attrs.push_back(attribute);
  90                                 el_end = pos;
  91                         } else
  92                         {
  93                                 string::size_type pos = txt.find_first_of(".#[:(", el_end + 1);
  94                                 string name = txt.substr(el_end + 1, pos - el_end - 1);
  95                                 lcase(name);
  96                                 attribute.name = _id(name);
  97                                 if(attribute.name == _after_ || attribute.name == _before_)
  98                                 {
  99                                         attribute.type  = select_pseudo_element;
 100                                 } else
 101                                 {
 102                                         attribute.type  = select_pseudo_class;
 103                                 }
 104
 105                                 string val;
 106                                 if(pos != string::npos && txt.at(pos) == '(')
 107                                 {
 108                                         auto end = find_close_bracket(txt, pos);
 109                                         val = txt.substr(pos + 1, end - pos - 1);
 110                                         if (end != string::npos) pos = end + 1;
 111                                 }
 112
 113                                 switch (attribute.name)
 114                                 {
 115                                 case _nth_child_:
 116                                 case _nth_of_type_:
 117                                 case _nth_last_child_:
 118                                 case _nth_last_of_type_:
 119                                         lcase(val);
 120                                         parse_nth_child_params(val, attribute.a, attribute.b);
 121                                         break;
 122                                 case _not_:
 123                                         attribute.sel = std::make_shared<css_element_selector>();
 124                                         attribute.sel->parse(val);
 125                                         break;
 126                                 case _lang_:
 127                                         trim(val);
 128                                         lcase(val);
 129                                         attribute.val = val;
 130                                         break;
 131                                 }
 132
 133                                 m_attrs.push_back(attribute);
 134                                 el_end = pos;
 135                         }
 136                 } else if(txt[el_end] == '[')
 137                 {
 138                         css_attribute_selector attribute;
 139
 140                         string::size_type pos = txt.find_first_of("]~=|$*^", el_end + 1);
 141                         string attr = txt.substr(el_end + 1, pos - el_end - 1);
 142                         trim(attr);
 143                         litehtml::lcase(attr);
 144                         if(pos != string::npos)
 145                         {
 146                                 if(txt[pos] == ']')
 147                                 {
 148                                         attribute.type = select_exists;
 149                                 } else if(txt[pos] == '=')
 150                                 {
 151                                         attribute.type = select_equal;
 152                                         pos++;
 153                                 } else if(txt.substr(pos, 2) == "~=")
 154                                 {
 155                                         attribute.type = select_contain_str;
 156                                         pos += 2;
 157                                 } else if(txt.substr(pos, 2) == "|=")
 158                                 {
 159                                         attribute.type = select_start_str;
 160                                         pos += 2;
 161                                 } else if(txt.substr(pos, 2) == "^=")
 162                                 {
 163                                         attribute.type = select_start_str;
 164                                         pos += 2;
 165                                 } else if(txt.substr(pos, 2) == "$=")
 166                                 {
 167                                         attribute.type = select_end_str;
 168                                         pos += 2;
 169                                 } else if(txt.substr(pos, 2) == "*=")
 170                                 {
 171                                         attribute.type = select_contain_str;
 172                                         pos += 2;
 173                                 } else
 174                                 {
 175                                         attribute.type = select_exists;
 176                                         pos += 1;
 177                                 }
 178                                 pos = txt.find_first_not_of(" \t", pos);
 179                                 if(pos != string::npos)
 180                                 {
 181                                         if(txt[pos] == '"')
 182                                         {
 183                                                 string::size_type pos2 = txt.find_first_of('\"', pos + 1);
 184                                                 attribute.val = txt.substr(pos + 1, pos2 == string::npos ? pos2 : (pos2 - pos - 1));
 185                                                 pos = pos2 == string::npos ? pos2 : (pos2 + 1);
 186                                         } else if(txt[pos] == '\'')
 187                                         {
 188                                                 string::size_type pos2 = txt.find_first_of('\'', pos + 1);
 189                                                 attribute.val = txt.substr(pos + 1, pos2 == string::npos ? pos2 : (pos2 - pos - 1));
 190                                                 pos = pos2 == string::npos ? pos2 : (pos2 + 1);
 191                                         } else if(txt[pos] == ']')
 192                                         {
 193                                                 pos ++;
 194                                         } else
 195                                         {
 196                                                 string::size_type pos2 = txt.find_first_of(']', pos + 1);
 197                                                 attribute.val = txt.substr(pos, pos2 == string::npos ? pos2 : (pos2 - pos));
 198                                                 trim(attribute.val);
 199                                                 pos = pos2 == string::npos ? pos2 : (pos2 + 1);
 200                                         }
 201                                 }
 202                         } else
 203                         {
 204                                 attribute.type = select_exists;
 205                         }
 206                         attribute.name = _id(attr);
 207                         m_attrs.push_back(attribute);
 208                         el_end = pos;
 209                 } else
 210                 {
 211                         el_end++;
 212                 }
 213                 el_end = txt.find_first_of(".#[:", el_end);
 214         }
 215 }
 216
 217
 218 bool litehtml::css_selector::parse( const string& text )
 219 {
 220         if(text.empty())
 221         {
 222                 return false;
 223         }
 224         string_vector tokens;
 225         split_string(text, tokens, "", " \t>+~", "([");
 226
 227         if(tokens.empty())
 228         {
 229                 return false;
 230         }
 231
 232         string left;
 233         string right = tokens.back();
 234         char combinator = 0;
 235
 236         tokens.pop_back();
 237         while(!tokens.empty() && (tokens.back() == " " || tokens.back() == "\t" || tokens.back() == "+" || tokens.back() == "~" || tokens.back() == ">"))
 238         {
 239                 if(combinator == ' ' || combinator == 0)
 240                 {
 241                         combinator = tokens.back()[0];
 242                 }
 243                 tokens.pop_back();
 244         }
 245
 246         for(const auto & token : tokens)
 247         {
 248                 left += token;
 249         }
 250
 251         trim(left);
 252         trim(right);
 253
 254         if(right.empty())
 255         {
 256                 return false;
 257         }
 258
 259         m_right.parse(right);
 260
 261         switch(combinator)
 262         {
 263         case '>':
 264                 m_combinator    = combinator_child;
 265                 break;
 266         case '+':
 267                 m_combinator    = combinator_adjacent_sibling;
 268                 break;
 269         case '~':
 270                 m_combinator    = combinator_general_sibling;
 271                 break;
 272         default:
 273                 m_combinator    = combinator_descendant;
 274                 break;
 275         }
 276
 277         m_left = nullptr;
 278
 279         if(!left.empty())
 280         {
 281                 m_left = std::make_shared<css_selector>();
 282                 if(!m_left->parse(left))
 283                 {
 284                         return false;
 285                 }
 286         }
 287
 288         return true;
 289 }
 290
 291 void litehtml::css_selector::calc_specificity()
 292 {
 293         if(m_right.m_tag != star_id)
 294         {
 295                 m_specificity.d = 1;
 296         }
 297         for(const auto& attr : m_right.m_attrs)
 298         {
 299                 if(attr.type == select_id)
 300                 {
 301                         m_specificity.b++;
 302                 } else
 303                 {
 304                         m_specificity.c++;
 305                 }
 306         }
 307         if(m_left)
 308         {
 309                 m_left->calc_specificity();
 310                 m_specificity += m_left->m_specificity;
 311         }
 312 }
 313
 314 void litehtml::css_selector::add_media_to_doc( document* doc ) const
 315 {
 316         if(m_media_query && doc)
 317         {
 318                 doc->add_media_list(m_media_query);
 319         }
 320 }
 321