src/plugins/litehtml_viewer/litehtml/formatting_context.cpp

   1 #include "html.h"
   2 #include "render_item.h"
   3 #include "formatting_context.h"
   4
   5 void litehtml::formatting_context::add_float(const std::shared_ptr<render_item> &el, int min_width, int context)
   6 {
   7         floated_box fb;
   8         fb.pos.x                = el->left() + m_current_left;
   9         fb.pos.y                = el->top() + m_current_top;
  10         fb.pos.width    = el->width();
  11         fb.pos.height   = el->height();
  12         fb.float_side   = el->src_el()->css().get_float();
  13         fb.clear_floats = el->src_el()->css().get_clear();
  14         fb.el                   = el;
  15         fb.context              = context;
  16         fb.min_width    = min_width;
  17
  18         if(fb.float_side == float_left)
  19         {
  20                 if(m_floats_left.empty())
  21                 {
  22                         m_floats_left.push_back(fb);
  23                 } else
  24                 {
  25                         bool inserted = false;
  26                         for(auto i = m_floats_left.begin(); i != m_floats_left.end(); i++)
  27                         {
  28                                 if(fb.pos.right() > i->pos.right())
  29                                 {
  30                                         m_floats_left.insert(i, std::move(fb));
  31                                         inserted = true;
  32                                         break;
  33                                 }
  34                         }
  35                         if(!inserted)
  36                         {
  37                                 m_floats_left.push_back(std::move(fb));
  38                         }
  39                 }
  40                 m_cache_line_left.invalidate();
  41         } else if(fb.float_side == float_right)
  42         {
  43                 if(m_floats_right.empty())
  44                 {
  45                         m_floats_right.push_back(std::move(fb));
  46                 } else
  47                 {
  48                         bool inserted = false;
  49                         for(auto i = m_floats_right.begin(); i != m_floats_right.end(); i++)
  50                         {
  51                                 if(fb.pos.left() < i->pos.left())
  52                                 {
  53                                         m_floats_right.insert(i, std::move(fb));
  54                                         inserted = true;
  55                                         break;
  56                                 }
  57                         }
  58                         if(!inserted)
  59                         {
  60                                 m_floats_right.push_back(fb);
  61                         }
  62                 }
  63                 m_cache_line_right.invalidate();
  64         }
  65 }
  66
  67 int litehtml::formatting_context::get_floats_height(element_float el_float) const
  68 {
  69         int h = 0;
  70
  71         for(const auto& fb : m_floats_left)
  72         {
  73                 bool process = false;
  74                 switch(el_float)
  75                 {
  76                         case float_none:
  77                                 process = true;
  78                                 break;
  79                         case float_left:
  80                                 if (fb.clear_floats == clear_left || fb.clear_floats == clear_both)
  81                                 {
  82                                         process = true;
  83                                 }
  84                                 break;
  85                         case float_right:
  86                                 if (fb.clear_floats == clear_right || fb.clear_floats == clear_both)
  87                                 {
  88                                         process = true;
  89                                 }
  90                                 break;
  91                 }
  92                 if(process)
  93                 {
  94                         if(el_float == float_none)
  95                         {
  96                                 h = std::max(h, fb.pos.bottom());
  97                         } else
  98                         {
  99                                 h = std::max(h, fb.pos.top());
 100                         }
 101                 }
 102         }
 103
 104
 105         for(const auto& fb : m_floats_right)
 106         {
 107                 int process = false;
 108                 switch(el_float)
 109                 {
 110                         case float_none:
 111                                 process = true;
 112                                 break;
 113                         case float_left:
 114                                 if (fb.clear_floats == clear_left || fb.clear_floats == clear_both)
 115                                 {
 116                                         process = true;
 117                                 }
 118                                 break;
 119                         case float_right:
 120                                 if (fb.clear_floats == clear_right || fb.clear_floats == clear_both)
 121                                 {
 122                                         process = true;
 123                                 }
 124                                 break;
 125                 }
 126                 if(process)
 127                 {
 128                         if(el_float == float_none)
 129                         {
 130                                 h = std::max(h, fb.pos.bottom());
 131                         } else
 132                         {
 133                                 h = std::max(h, fb.pos.top());
 134                         }
 135                 }
 136         }
 137
 138         return h - m_current_top;
 139 }
 140
 141 int litehtml::formatting_context::get_left_floats_height() const
 142 {
 143         int h = 0;
 144         if(!m_floats_left.empty())
 145         {
 146                 for (const auto& fb : m_floats_left)
 147                 {
 148                         h = std::max(h, fb.pos.bottom());
 149                 }
 150         }
 151         return h - m_current_top;
 152 }
 153
 154 int litehtml::formatting_context::get_right_floats_height() const
 155 {
 156         int h = 0;
 157         if(!m_floats_right.empty())
 158         {
 159                 for(const auto& fb : m_floats_right)
 160                 {
 161                         h = std::max(h, fb.pos.bottom());
 162                 }
 163         }
 164         return h - m_current_top;
 165 }
 166
 167 int litehtml::formatting_context::get_line_left(int y )
 168 {
 169         y += m_current_top;
 170
 171         if(m_cache_line_left.is_valid && m_cache_line_left.hash == y)
 172         {
 173                 if(m_cache_line_left.val - m_current_left < 0)
 174                 {
 175                         return 0;
 176                 }
 177                 return m_cache_line_left.val - m_current_left;
 178         }
 179
 180         int w = 0;
 181         for(const auto& fb : m_floats_left)
 182         {
 183                 if (y >= fb.pos.top() && y < fb.pos.bottom())
 184                 {
 185                         w = std::max(w, fb.pos.right());
 186                         if (w < fb.pos.right())
 187                         {
 188                                 break;
 189                         }
 190                 }
 191         }
 192         m_cache_line_left.set_value(y, w);
 193         w -= m_current_left;
 194         if(w < 0) return 0;
 195         return w;
 196 }
 197
 198 int litehtml::formatting_context::get_line_right(int y, int def_right )
 199 {
 200         y += m_current_top;
 201         def_right += m_current_left;
 202         if(m_cache_line_right.is_valid && m_cache_line_right.hash == y)
 203         {
 204                 if(m_cache_line_right.is_default)
 205                 {
 206                         return def_right - m_current_left;
 207                 } else
 208                 {
 209                         int w = std::min(m_cache_line_right.val, def_right) - m_current_left;
 210                         if(w < 0) return 0;
 211                         return w;
 212                 }
 213         }
 214
 215         int w = def_right;
 216         m_cache_line_right.is_default = true;
 217         for(const auto& fb : m_floats_right)
 218         {
 219                 if(y >= fb.pos.top() && y < fb.pos.bottom())
 220                 {
 221                         w = std::min(w, fb.pos.left());
 222                         m_cache_line_right.is_default = false;
 223                         if(w > fb.pos.left())
 224                         {
 225                                 break;
 226                         }
 227                 }
 228         }
 229         m_cache_line_right.set_value(y, w);
 230         w -= m_current_left;
 231         if(w < 0) return 0;
 232         return w;
 233 }
 234
 235
 236 void litehtml::formatting_context::clear_floats(int context)
 237 {
 238         auto iter = m_floats_left.begin();
 239         while(iter != m_floats_left.end())
 240         {
 241                 if(iter->context >= context)
 242                 {
 243                         iter = m_floats_left.erase(iter);
 244                         m_cache_line_left.invalidate();
 245                 } else
 246                 {
 247                         iter++;
 248                 }
 249         }
 250
 251         iter = m_floats_right.begin();
 252         while(iter != m_floats_right.end())
 253         {
 254                 if(iter->context >= context)
 255                 {
 256                         iter = m_floats_right.erase(iter);
 257                         m_cache_line_right.invalidate();
 258                 } else
 259                 {
 260                         iter++;
 261                 }
 262         }
 263 }
 264
 265 int litehtml::formatting_context::get_cleared_top(const std::shared_ptr<render_item> &el, int line_top) const
 266 {
 267         switch(el->src_el()->css().get_clear())
 268         {
 269                 case clear_left:
 270                         {
 271                                 int fh = get_left_floats_height();
 272                                 if(fh && fh > line_top)
 273                                 {
 274                                         line_top = fh;
 275                                 }
 276                         }
 277                         break;
 278                 case clear_right:
 279                         {
 280                                 int fh = get_right_floats_height();
 281                                 if(fh && fh > line_top)
 282                                 {
 283                                         line_top = fh;
 284                                 }
 285                         }
 286                         break;
 287                 case clear_both:
 288                         {
 289                                 int fh = get_floats_height(float_none);
 290                                 if(fh && fh > line_top)
 291                                 {
 292                                         line_top = fh;
 293                                 }
 294                         }
 295                         break;
 296                 default:
 297                         if(el->src_el()->css().get_float() != float_none)
 298                         {
 299                                 int fh = get_floats_height(el->src_el()->css().get_float());
 300                                 if(fh && fh > line_top)
 301                                 {
 302                                         line_top = fh;
 303                                 }
 304                         }
 305                         break;
 306         }
 307         return line_top;
 308 }
 309
 310 int litehtml::formatting_context::find_next_line_top(int top, int width, int def_right )
 311 {
 312         top += m_current_top;
 313         def_right += m_current_left;
 314
 315         int new_top = top;
 316         int_vector points;
 317
 318         for(const auto& fb : m_floats_left)
 319         {
 320                 if(fb.pos.top() >= top)
 321                 {
 322                         if(find(points.begin(), points.end(), fb.pos.top()) == points.end())
 323                         {
 324                                 points.push_back(fb.pos.top());
 325                         }
 326                 }
 327                 if (fb.pos.bottom() >= top)
 328                 {
 329                         if (find(points.begin(), points.end(), fb.pos.bottom()) == points.end())
 330                         {
 331                                 points.push_back(fb.pos.bottom());
 332                         }
 333                 }
 334         }
 335
 336         for (const auto& fb : m_floats_right)
 337         {
 338                 if (fb.pos.top() >= top)
 339                 {
 340                         if (find(points.begin(), points.end(), fb.pos.top()) == points.end())
 341                         {
 342                                 points.push_back(fb.pos.top());
 343                         }
 344                 }
 345                 if (fb.pos.bottom() >= top)
 346                 {
 347                         if (find(points.begin(), points.end(), fb.pos.bottom()) == points.end())
 348                         {
 349                                 points.push_back(fb.pos.bottom());
 350                         }
 351                 }
 352         }
 353
 354         if(!points.empty())
 355         {
 356                 sort(points.begin(), points.end(), std::less<int>( ));
 357                 new_top = points.back();
 358
 359                 for(auto pt : points)
 360                 {
 361                         int pos_left    = 0;
 362                         int pos_right   = def_right;
 363                         get_line_left_right(pt - m_current_top, def_right - m_current_left, pos_left, pos_right);
 364
 365                         if(pos_right - pos_left >= width)
 366                         {
 367                                 new_top = pt;
 368                                 break;
 369                         }
 370                 }
 371         }
 372         return new_top - m_current_top;
 373 }
 374
 375 void litehtml::formatting_context::update_floats(int dy, const std::shared_ptr<render_item> &parent)
 376 {
 377         bool reset_cache = false;
 378         for(auto fb = m_floats_left.rbegin(); fb != m_floats_left.rend(); fb++)
 379         {
 380                 if(fb->el->src_el()->is_ancestor(parent->src_el()))
 381                 {
 382                         reset_cache     = true;
 383                         fb->pos.y       += dy;
 384                 }
 385         }
 386         if(reset_cache)
 387         {
 388                 m_cache_line_left.invalidate();
 389         }
 390         reset_cache = false;
 391         for(auto fb = m_floats_right.rbegin(); fb != m_floats_right.rend(); fb++)
 392         {
 393                 if(fb->el->src_el()->is_ancestor(parent->src_el()))
 394                 {
 395                         reset_cache     = true;
 396                         fb->pos.y       += dy;
 397                 }
 398         }
 399         if(reset_cache)
 400         {
 401                 m_cache_line_right.invalidate();
 402         }
 403 }
 404
 405 void litehtml::formatting_context::apply_relative_shift(const containing_block_context &containing_block_size)
 406 {
 407         for (const auto& fb : m_floats_left)
 408         {
 409                 fb.el->apply_relative_shift(containing_block_size);
 410         }
 411 }
 412
 413 int litehtml::formatting_context::find_min_left(int y, int context_idx)
 414 {
 415         y += m_current_top;
 416         int min_left = m_current_left;
 417         for(const auto& fb : m_floats_left)
 418         {
 419                 if (y >= fb.pos.top() && y < fb.pos.bottom() && fb.context == context_idx)
 420                 {
 421                         min_left += fb.min_width;
 422                 }
 423         }
 424         if(min_left < m_current_left) return 0;
 425         return min_left - m_current_left;
 426 }
 427
 428 int litehtml::formatting_context::find_min_right(int y, int right, int context_idx)
 429 {
 430         y += m_current_top;
 431         int min_right = right + m_current_left;
 432         for(const auto& fb : m_floats_right)
 433         {
 434                 if (y >= fb.pos.top() && y < fb.pos.bottom() && fb.context == context_idx)
 435                 {
 436                         min_right -= fb.min_width;
 437                 }
 438         }
 439         if(min_right < m_current_left) return 0;
 440         return min_right - m_current_left;
 441 }