src/plugins/litehtml_viewer/litehtml/css_selector.h

   1 #ifndef LH_CSS_SELECTOR_H
   2 #define LH_CSS_SELECTOR_H
   3
   4 #include "style.h"
   5 #include "media_query.h"
   6
   7 namespace litehtml
   8 {
   9         //////////////////////////////////////////////////////////////////////////
  10
  11         struct selector_specificity
  12         {
  13                 int             a;
  14                 int             b;
  15                 int             c;
  16                 int             d;
  17
  18                 explicit selector_specificity(int va = 0, int vb = 0, int vc = 0, int vd = 0)
  19                 {
  20                         a       = va;
  21                         b       = vb;
  22                         c       = vc;
  23                         d       = vd;
  24                 }
  25
  26                 void operator += (const selector_specificity& val)
  27                 {
  28                         a       += val.a;
  29                         b       += val.b;
  30                         c       += val.c;
  31                         d       += val.d;
  32                 }
  33
  34                 bool operator==(const selector_specificity& val) const
  35                 {
  36                         if(a == val.a && b == val.b && c == val.c && d == val.d)
  37                         {
  38                                 return true;
  39                         }
  40                         return false;
  41                 }
  42
  43                 bool operator!=(const selector_specificity& val) const
  44                 {
  45                         if(a != val.a || b != val.b || c != val.c || d != val.d)
  46                         {
  47                                 return true;
  48                         }
  49                         return false;
  50                 }
  51
  52                 bool operator > (const selector_specificity& val) const
  53                 {
  54                         if(a > val.a)
  55                         {
  56                                 return true;
  57                         } else if(a < val.a)
  58                         {
  59                                 return false;
  60                         } else
  61                         {
  62                                 if(b > val.b)
  63                                 {
  64                                         return true;
  65                                 } else if(b < val.b)
  66                                 {
  67                                         return false;
  68                                 } else
  69                                 {
  70                                         if(c > val.c)
  71                                         {
  72                                                 return true;
  73                                         } else if(c < val.c)
  74                                         {
  75                                                 return false;
  76                                         } else
  77                                         {
  78                                                 if(d > val.d)
  79                                                 {
  80                                                         return true;
  81                                                 } else if(d < val.d)
  82                                                 {
  83                                                         return false;
  84                                                 }
  85                                         }
  86                                 }
  87                         }
  88                         return false;
  89                 }
  90
  91                 bool operator >= (const selector_specificity& val) const
  92                 {
  93                         if((*this) == val) return true;
  94                         if((*this) > val) return true;
  95                         return false;
  96                 }
  97
  98                 bool operator <= (const selector_specificity& val) const
  99                 {
 100                         if((*this) > val)
 101                         {
 102                                 return false;
 103                         }
 104                         return true;
 105                 }
 106
 107                 bool operator < (const selector_specificity& val) const
 108                 {
 109                         if((*this) <= val && (*this) != val)
 110                         {
 111                                 return true;
 112                         }
 113                         return false;
 114                 }
 115
 116         };
 117
 118         //////////////////////////////////////////////////////////////////////////
 119
 120         enum attr_select_type
 121         {
 122                 select_class,
 123                 select_id,
 124
 125                 select_exists,
 126                 select_equal,
 127                 select_contain_str,
 128                 select_start_str,
 129                 select_end_str,
 130
 131                 select_pseudo_class,
 132                 select_pseudo_element,
 133         };
 134
 135         //////////////////////////////////////////////////////////////////////////
 136
 137         class css_element_selector;
 138
 139         struct css_attribute_selector
 140         {
 141                 typedef std::vector<css_attribute_selector>     vector;
 142
 143                 attr_select_type        type;
 144                 string_id                       name; // .name, #name, [name], :name
 145                 string                          val;  // [name=val], :lang(val)
 146
 147                 std::shared_ptr<css_element_selector> sel; // :not(sel)
 148                 int a, b; // :nth-child(an+b)
 149
 150                 css_attribute_selector()
 151                 {
 152                         type = select_class;
 153                         name = empty_id;
 154                         a = b = 0;
 155                 }
 156         };
 157
 158         //////////////////////////////////////////////////////////////////////////
 159
 160         class css_element_selector
 161         {
 162         public:
 163                 string_id                                               m_tag;
 164                 css_attribute_selector::vector  m_attrs;
 165         public:
 166
 167                 void parse(const string& txt);
 168                 static void parse_nth_child_params(const string& param, int& num, int& off);
 169         };
 170
 171         //////////////////////////////////////////////////////////////////////////
 172
 173         enum css_combinator
 174         {
 175                 combinator_descendant,
 176                 combinator_child,
 177                 combinator_adjacent_sibling,
 178                 combinator_general_sibling
 179         };
 180
 181         //////////////////////////////////////////////////////////////////////////
 182
 183         class css_selector
 184         {
 185         public:
 186                 typedef std::shared_ptr<css_selector>   ptr;
 187                 typedef std::vector<css_selector::ptr>  vector;
 188         public:
 189                 selector_specificity    m_specificity;
 190                 css_element_selector    m_right;
 191                 css_selector::ptr               m_left;
 192                 css_combinator                  m_combinator;
 193                 style::ptr                              m_style;
 194                 int                                             m_order;
 195                 media_query_list::ptr   m_media_query;
 196         public:
 197                 explicit css_selector(const media_query_list::ptr& media = nullptr)
 198                 {
 199                         m_media_query   = media;
 200                         m_combinator    = combinator_descendant;
 201                         m_order                 = 0;
 202                 }
 203
 204                 ~css_selector() = default;
 205
 206                 css_selector(const css_selector& val)
 207                 {
 208                         m_right                 = val.m_right;
 209                         if(val.m_left)
 210                         {
 211                                 m_left = std::make_shared<css_selector>(*val.m_left);
 212                         } else
 213                         {
 214                                 m_left = nullptr;
 215                         }
 216                         m_combinator    = val.m_combinator;
 217                         m_specificity   = val.m_specificity;
 218                         m_order                 = val.m_order;
 219                         m_media_query   = val.m_media_query;
 220                 }
 221
 222                 bool parse(const string& text);
 223                 void calc_specificity();
 224                 bool is_media_valid() const;
 225                 void add_media_to_doc(document* doc) const;
 226         };
 227
 228         inline bool css_selector::is_media_valid() const
 229         {
 230                 if(!m_media_query)
 231                 {
 232                         return true;
 233                 }
 234                 return m_media_query->is_used();
 235         }
 236
 237
 238         //////////////////////////////////////////////////////////////////////////
 239
 240         inline bool operator > (const css_selector& v1, const css_selector& v2)
 241         {
 242                 if(v1.m_specificity == v2.m_specificity)
 243                 {
 244                         return (v1.m_order > v2.m_order);
 245                 }
 246                 return (v1.m_specificity > v2.m_specificity);
 247         }
 248
 249         inline bool operator < (const css_selector& v1, const css_selector& v2)
 250         {
 251                 if(v1.m_specificity == v2.m_specificity)
 252                 {
 253                         return (v1.m_order < v2.m_order);
 254                 }
 255                 return (v1.m_specificity < v2.m_specificity);
 256         }
 257
 258         inline bool operator > (const css_selector::ptr& v1, const css_selector::ptr& v2)
 259         {
 260                 return (*v1 > *v2);
 261         }
 262
 263         inline bool operator < (const css_selector::ptr& v1, const css_selector::ptr& v2)
 264         {
 265                 return (*v1 < *v2);
 266         }
 267
 268         //////////////////////////////////////////////////////////////////////////
 269
 270         class used_selector
 271         {
 272         public:
 273                 typedef std::unique_ptr<used_selector>  ptr;
 274                 typedef std::vector<used_selector::ptr> vector;
 275
 276                 css_selector::ptr       m_selector;
 277                 bool                            m_used;
 278
 279                 used_selector(const css_selector::ptr& selector, bool used)
 280                 {
 281                         m_used          = used;
 282                         m_selector      = selector;
 283                 }
 284
 285                 used_selector(const used_selector& val)
 286                 {
 287                         m_used = val.m_used;
 288                         m_selector = val.m_selector;
 289                 }
 290
 291                 used_selector& operator=(const used_selector& val)
 292                 {
 293                         m_used = val.m_used;
 294                         m_selector = val.m_selector;
 295                         return *this;
 296                 }
 297         };
 298 }
 299
 300 #endif  // LH_CSS_SELECTOR_H