src/plugins/litehtml_viewer/litehtml/render_inline_context.cpp

   1 #include "html.h"
   2 #include "render_inline_context.h"
   3 #include "document.h"
   4 #include "iterators.h"
   5
   6 int litehtml::render_item_inline_context::_render_content(int x, int y, bool second_pass, const containing_block_context &self_size, formatting_context* fmt_ctx)
   7 {
   8     m_line_boxes.clear();
   9         m_max_line_width = 0;
  10
  11     white_space ws = src_el()->css().get_white_space();
  12     bool skip_spaces = false;
  13     if (ws == white_space_normal ||
  14         ws == white_space_nowrap ||
  15         ws == white_space_pre_line)
  16     {
  17         skip_spaces = true;
  18     }
  19
  20     bool was_space = false;
  21
  22     go_inside_inline go_inside_inlines_selector;
  23     inline_selector select_inlines;
  24     elements_iterator inlines_iter(true, &go_inside_inlines_selector, &select_inlines);
  25
  26     inlines_iter.process(shared_from_this(), [&](const std::shared_ptr<render_item>& el, iterator_item_type item_type)
  27         {
  28                         switch (item_type)
  29                         {
  30                                 case iterator_item_type_child:
  31                                         {
  32                                                 // skip spaces to make rendering a bit faster
  33                                                 if (skip_spaces)
  34                                                 {
  35                                                         if (el->src_el()->is_white_space())
  36                                                         {
  37                                                                 if (was_space)
  38                                                                 {
  39                                                                         el->skip(true);
  40                                                                         return;
  41                                                                 } else
  42                                                                 {
  43                                                                         was_space = true;
  44                                                                 }
  45                                                         } else
  46                                                         {
  47                                                                 // skip all spaces after line break
  48                                                                 was_space = el->src_el()->is_break();
  49                                                         }
  50                                                 }
  51                                                 // place element into rendering flow
  52                                                 place_inline(std::unique_ptr<line_box_item>(new line_box_item(el)), self_size, fmt_ctx);
  53                                         }
  54                                         break;
  55
  56                                 case iterator_item_type_start_parent:
  57                                         {
  58                                                 el->clear_inline_boxes();
  59                                                 place_inline(std::unique_ptr<lbi_start>(new lbi_start(el)), self_size, fmt_ctx);
  60                                         }
  61                                         break;
  62
  63                                 case iterator_item_type_end_parent:
  64                                 {
  65                                         place_inline(std::unique_ptr<lbi_end>(new lbi_end(el)), self_size, fmt_ctx);
  66                                 }
  67                                         break;
  68                         }
  69         });
  70
  71     finish_last_box(true, self_size);
  72
  73     if (!m_line_boxes.empty())
  74     {
  75         if (collapse_top_margin())
  76         {
  77             int old_top = m_margins.top;
  78             m_margins.top = std::max(m_line_boxes.front()->top_margin(), m_margins.top);
  79             if (m_margins.top != old_top)
  80             {
  81                 fmt_ctx->update_floats(m_margins.top - old_top, shared_from_this());
  82             }
  83         }
  84         if (collapse_bottom_margin())
  85         {
  86             m_margins.bottom = std::max(m_line_boxes.back()->bottom_margin(), m_margins.bottom);
  87             m_pos.height = m_line_boxes.back()->bottom() - m_line_boxes.back()->bottom_margin();
  88         }
  89         else
  90         {
  91             m_pos.height = m_line_boxes.back()->bottom();
  92         }
  93     }
  94
  95     return m_max_line_width;
  96 }
  97
  98 void litehtml::render_item_inline_context::fix_line_width(element_float flt,
  99                                                                                                                   const containing_block_context &self_size,
 100                                                                                                                   formatting_context* fmt_ctx)
 101 {
 102     if(!m_line_boxes.empty())
 103     {
 104                 auto el_front = m_line_boxes.back()->get_first_text_part();
 105
 106         std::vector<std::shared_ptr<render_item>> els;
 107         bool was_cleared = false;
 108         if(el_front && el_front->src_el()->css().get_clear() != clear_none)
 109         {
 110             if(el_front->src_el()->css().get_clear() == clear_both)
 111             {
 112                 was_cleared = true;
 113             } else
 114             {
 115                 if(     (flt == float_left      && el_front->src_el()->css().get_clear() == clear_left) ||
 116                        (flt == float_right      && el_front->src_el()->css().get_clear() == clear_right) )
 117                 {
 118                     was_cleared = true;
 119                 }
 120             }
 121         }
 122
 123         if(!was_cleared)
 124         {
 125                         std::list<std::unique_ptr<line_box_item> > items = std::move(m_line_boxes.back()->items());
 126             m_line_boxes.pop_back();
 127
 128             for(auto& item : items)
 129             {
 130                 place_inline(std::move(item), self_size, fmt_ctx);
 131             }
 132         } else
 133         {
 134             int line_top = 0;
 135             line_top = m_line_boxes.back()->top();
 136
 137             int line_left       = 0;
 138             int line_right      = self_size.render_width;
 139             fmt_ctx->get_line_left_right(line_top, self_size.render_width, line_left, line_right);
 140
 141             if(m_line_boxes.size() == 1)
 142             {
 143                 if (src_el()->css().get_list_style_type() != list_style_type_none && src_el()->css().get_list_style_position() == list_style_position_inside)
 144                 {
 145                     int sz_font = src_el()->css().get_font_size();
 146                     line_left += sz_font;
 147                 }
 148
 149                 if (src_el()->css().get_text_indent().val() != 0)
 150                 {
 151                     line_left += src_el()->css().get_text_indent().calc_percent(self_size.width);
 152                 }
 153
 154             }
 155
 156             auto items = m_line_boxes.back()->new_width(line_left, line_right);
 157             for(auto& item : items)
 158             {
 159                 place_inline(std::move(item), self_size, fmt_ctx);
 160             }
 161         }
 162     }
 163 }
 164
 165 std::list<std::unique_ptr<litehtml::line_box_item> > litehtml::render_item_inline_context::finish_last_box(bool end_of_render, const containing_block_context &self_size)
 166 {
 167         std::list<std::unique_ptr<line_box_item> > ret;
 168
 169     if(!m_line_boxes.empty())
 170     {
 171                 ret = m_line_boxes.back()->finish(end_of_render, self_size);
 172
 173         if(m_line_boxes.back()->is_empty() && end_of_render)
 174         {
 175                         // remove the last empty line
 176             m_line_boxes.pop_back();
 177         } else
 178                 {
 179                         m_max_line_width = std::max(m_max_line_width, m_line_boxes.back()->min_width());
 180                 }
 181     }
 182     return ret;
 183 }
 184
 185 int litehtml::render_item_inline_context::new_box(const std::unique_ptr<line_box_item>& el, line_context& line_ctx, const containing_block_context &self_size, formatting_context* fmt_ctx)
 186 {
 187         auto items = finish_last_box(false, self_size);
 188         int line_top = 0;
 189         if(!m_line_boxes.empty())
 190         {
 191                 line_top = m_line_boxes.back()->bottom();
 192         }
 193     line_ctx.top = fmt_ctx->get_cleared_top(el->get_el(), line_top);
 194
 195     line_ctx.left = 0;
 196     line_ctx.right = self_size.render_width;
 197     line_ctx.fix_top();
 198         fmt_ctx->get_line_left_right(line_ctx.top, self_size.render_width, line_ctx.left, line_ctx.right);
 199
 200     if(el->get_el()->src_el()->is_inline() || el->get_el()->src_el()->is_block_formatting_context())
 201     {
 202         if (el->get_el()->width() > line_ctx.right - line_ctx.left)
 203         {
 204             line_ctx.top = fmt_ctx->find_next_line_top(line_ctx.top, el->get_el()->width(), self_size.render_width);
 205             line_ctx.left = 0;
 206             line_ctx.right = self_size.render_width;
 207             line_ctx.fix_top();
 208                         fmt_ctx->get_line_left_right(line_ctx.top, self_size.render_width, line_ctx.left, line_ctx.right);
 209         }
 210     }
 211
 212     int first_line_margin = 0;
 213     int text_indent = 0;
 214     if(m_line_boxes.empty())
 215     {
 216         if(src_el()->css().get_list_style_type() != list_style_type_none && src_el()->css().get_list_style_position() == list_style_position_inside)
 217         {
 218             int sz_font = src_el()->css().get_font_size();
 219             first_line_margin = sz_font;
 220         }
 221         if(src_el()->css().get_text_indent().val() != 0)
 222         {
 223             text_indent = src_el()->css().get_text_indent().calc_percent(self_size.width);
 224         }
 225     }
 226
 227     m_line_boxes.emplace_back(std::unique_ptr<line_box>(new line_box(
 228                         line_ctx.top,
 229                         line_ctx.left + first_line_margin + text_indent, line_ctx.right,
 230                         css().get_line_height(),
 231                         css().get_font_metrics(),
 232                         css().get_text_align())));
 233
 234         // Add items returned by finish_last_box function into the new line
 235         for(auto& it : items)
 236         {
 237                 m_line_boxes.back()->add_item(std::move(it));
 238         }
 239
 240     return line_ctx.top;
 241 }
 242
 243 void litehtml::render_item_inline_context::place_inline(std::unique_ptr<line_box_item> item, const containing_block_context &self_size, formatting_context* fmt_ctx)
 244 {
 245     if(item->get_el()->src_el()->css().get_display() == display_none) return;
 246
 247     if(item->get_el()->src_el()->is_float())
 248     {
 249         int line_top = 0;
 250         if(!m_line_boxes.empty())
 251         {
 252             line_top = m_line_boxes.back()->top();
 253         }
 254         int ret = place_float(item->get_el(), line_top, self_size, fmt_ctx);
 255                 if(ret > m_max_line_width)
 256                 {
 257                         m_max_line_width = ret;
 258                 }
 259                 return;
 260     }
 261
 262     line_context line_ctx = {0};
 263     line_ctx.top = 0;
 264     if (!m_line_boxes.empty())
 265     {
 266         line_ctx.top = m_line_boxes.back().get()->top();
 267     }
 268     line_ctx.left = 0;
 269     line_ctx.right = self_size.render_width;
 270     line_ctx.fix_top();
 271         fmt_ctx->get_line_left_right(line_ctx.top, self_size.render_width, line_ctx.left, line_ctx.right);
 272
 273         if(item->get_type() == line_box_item::type_text_part)
 274         {
 275                 if(item->get_el()->src_el()->is_inline_box())
 276                 {
 277                         int min_rendered_width = item->get_el()->render(line_ctx.left, line_ctx.top, self_size.new_width(line_ctx.right), fmt_ctx);
 278                         if(min_rendered_width < item->get_el()->width() && item->get_el()->src_el()->css().get_width().is_predefined())
 279                         {
 280                                 item->get_el()->render(line_ctx.left, line_ctx.top, self_size.new_width(min_rendered_width), fmt_ctx);
 281                         }
 282                         item->set_rendered_min_width(min_rendered_width);
 283                 } else if(item->get_el()->src_el()->css().get_display() == display_inline_text)
 284                 {
 285                         litehtml::size sz;
 286                         item->get_el()->src_el()->get_content_size(sz, line_ctx.right);
 287                         item->get_el()->pos() = sz;
 288                         item->set_rendered_min_width(sz.width);
 289                 }
 290         }
 291
 292     bool add_box = true;
 293     if(!m_line_boxes.empty())
 294     {
 295         if(m_line_boxes.back()->can_hold(item, src_el()->css().get_white_space()))
 296         {
 297             add_box = false;
 298         }
 299     }
 300     if(add_box)
 301     {
 302         new_box(item, line_ctx, self_size, fmt_ctx);
 303     } else if(!m_line_boxes.empty())
 304     {
 305         line_ctx.top = m_line_boxes.back()->top();
 306     }
 307
 308     if (line_ctx.top != line_ctx.calculatedTop)
 309     {
 310         line_ctx.left = 0;
 311         line_ctx.right = self_size.render_width;
 312         line_ctx.fix_top();
 313                 fmt_ctx->get_line_left_right(line_ctx.top, self_size.render_width, line_ctx.left, line_ctx.right);
 314     }
 315
 316     if(!item->get_el()->src_el()->is_inline())
 317     {
 318         if(m_line_boxes.size() == 1)
 319         {
 320             if(collapse_top_margin())
 321             {
 322                 int shift = item->get_el()->margin_top();
 323                 if(shift >= 0)
 324                 {
 325                     line_ctx.top -= shift;
 326                     m_line_boxes.back()->y_shift(-shift);
 327                 }
 328             }
 329         } else
 330         {
 331             int shift = 0;
 332             int prev_margin = m_line_boxes[m_line_boxes.size() - 2]->bottom_margin();
 333
 334             if(prev_margin > item->get_el()->margin_top())
 335             {
 336                 shift = item->get_el()->margin_top();
 337             } else
 338             {
 339                 shift = prev_margin;
 340             }
 341             if(shift >= 0)
 342             {
 343                 line_ctx.top -= shift;
 344                 m_line_boxes.back()->y_shift(-shift);
 345             }
 346         }
 347     }
 348
 349         m_line_boxes.back()->add_item(std::move(item));
 350 }
 351
 352 void litehtml::render_item_inline_context::apply_vertical_align()
 353 {
 354     if(!m_line_boxes.empty())
 355     {
 356         int add = 0;
 357         int content_height      = m_line_boxes.back()->bottom();
 358
 359         if(m_pos.height > content_height)
 360         {
 361             switch(src_el()->css().get_vertical_align())
 362             {
 363                 case va_middle:
 364                     add = (m_pos.height - content_height) / 2;
 365                     break;
 366                 case va_bottom:
 367                     add = m_pos.height - content_height;
 368                     break;
 369                 default:
 370                     add = 0;
 371                     break;
 372             }
 373         }
 374
 375         if(add)
 376         {
 377             for(auto & box : m_line_boxes)
 378             {
 379                 box->y_shift(add);
 380             }
 381         }
 382     }
 383 }
 384
 385 int litehtml::render_item_inline_context::get_base_line()
 386 {
 387     auto el_parent = parent();
 388     if(el_parent && src_el()->css().get_display() == display_inline_flex)
 389     {
 390         return el_parent->get_base_line();
 391     }
 392     if(src_el()->is_replaced())
 393     {
 394         return 0;
 395     }
 396     int bl = 0;
 397     if(!m_line_boxes.empty())
 398     {
 399         bl = m_line_boxes.back()->baseline() + content_offset_bottom();
 400     }
 401     return bl;
 402 }