src/plugins/litehtml_viewer/litehtml/render_block.cpp

   1 #include "html.h"
   2 #include "render_block.h"
   3 #include "render_inline_context.h"
   4 #include "render_block_context.h"
   5 #include "document.h"
   6
   7 int litehtml::render_item_block::place_float(const std::shared_ptr<render_item> &el, int top, const containing_block_context &self_size, formatting_context* fmt_ctx)
   8 {
   9     int line_top        = fmt_ctx->get_cleared_top(el, top);
  10     int line_left       = 0;
  11     int line_right      = self_size.render_width;
  12         fmt_ctx->get_line_left_right(line_top, self_size.render_width, line_left, line_right);
  13
  14     int ret_width = 0;
  15
  16         int min_rendered_width = el->render(line_left, line_top, self_size.new_width(line_right), fmt_ctx);
  17         if(min_rendered_width < el->width() && el->src_el()->css().get_width().is_predefined())
  18         {
  19                 el->render(line_left, line_top, self_size.new_width(min_rendered_width), fmt_ctx);
  20         }
  21
  22     if (el->src_el()->css().get_float() == float_left)
  23     {
  24         if(el->right() > line_right)
  25         {
  26                         line_top = fmt_ctx->find_next_line_top(el->top(), el->width(), self_size.render_width);
  27             el->pos().x = fmt_ctx->get_line_left(line_top) + el->content_offset_left();
  28             el->pos().y = line_top + el->content_offset_top();
  29         }
  30                 fmt_ctx->add_float(el, min_rendered_width, self_size.context_idx);
  31                 fix_line_width(float_left, self_size, fmt_ctx);
  32
  33                 ret_width = fmt_ctx->find_min_left(line_top, self_size.context_idx);
  34     } else if (el->src_el()->css().get_float() == float_right)
  35     {
  36         if(line_left + el->width() > line_right)
  37         {
  38             int new_top = fmt_ctx->find_next_line_top(el->top(), el->width(), self_size.render_width);
  39             el->pos().x = fmt_ctx->get_line_right(new_top, self_size.render_width) - el->width() + el->content_offset_left();
  40             el->pos().y = new_top + el->content_offset_top();
  41         } else
  42         {
  43             el->pos().x = line_right - el->width() + el->content_offset_left();
  44         }
  45                 fmt_ctx->add_float(el, min_rendered_width, self_size.context_idx);
  46                 fix_line_width(float_right, self_size, fmt_ctx);
  47                 line_right = fmt_ctx->find_min_right(line_top, self_size.render_width, self_size.context_idx);
  48                 ret_width = self_size.render_width - line_right;
  49     }
  50     return ret_width;
  51 }
  52
  53 std::shared_ptr<litehtml::render_item> litehtml::render_item_block::init()
  54 {
  55     {
  56         css_selector sel;
  57         sel.parse(".inline_rating");
  58         if(src_el()->select(sel))
  59         {
  60             int i = 0;
  61             i++;
  62         }
  63     }
  64     std::shared_ptr<render_item> ret;
  65
  66     // Initialize indexes for list items
  67     if(src_el()->css().get_display() == display_list_item && src_el()->css().get_list_style_type() >= list_style_type_armenian)
  68     {
  69         if (auto p = src_el()->parent())
  70         {
  71             int val = atoi(p->get_attr("start", "1"));
  72                         for(const auto &child : p->children())
  73             {
  74                 if (child == src_el())
  75                 {
  76                     src_el()->set_attr("list_index", std::to_string(val).c_str());
  77                     break;
  78                 }
  79                 else if (child->css().get_display() == display_list_item)
  80                     val++;
  81             }
  82         }
  83     }
  84     // Split inline blocks with box blocks inside
  85     auto iter = m_children.begin();
  86     while (iter != m_children.end())
  87     {
  88         const auto& el = *iter;
  89         if(el->src_el()->css().get_display() == display_inline && !el->children().empty())
  90         {
  91             auto split_el = el->split_inlines();
  92             if(std::get<0>(split_el))
  93             {
  94                 iter = m_children.erase(iter);
  95                 iter = m_children.insert(iter, std::get<2>(split_el));
  96                 iter = m_children.insert(iter, std::get<1>(split_el));
  97                 iter = m_children.insert(iter, std::get<0>(split_el));
  98
  99                 std::get<0>(split_el)->parent(shared_from_this());
 100                 std::get<1>(split_el)->parent(shared_from_this());
 101                 std::get<2>(split_el)->parent(shared_from_this());
 102                 continue;
 103             }
 104         }
 105         ++iter;
 106     }
 107
 108     bool has_block_level = false;
 109         bool has_inlines = false;
 110         bool has_floats = false;
 111     for (const auto& el : m_children)
 112     {
 113                 if(!el->src_el()->is_float())
 114                 {
 115                         if (el->src_el()->is_block_box())
 116                         {
 117                                 has_block_level = true;
 118                         } else if (el->src_el()->is_inline())
 119                         {
 120                                 has_inlines = true;
 121                         }
 122                 }
 123         if(has_block_level && has_inlines)
 124             break;
 125     }
 126     if(has_block_level)
 127     {
 128         ret = std::make_shared<render_item_block_context>(src_el());
 129         ret->parent(parent());
 130
 131         auto doc = src_el()->get_document();
 132         decltype(m_children) new_children;
 133         decltype(m_children) inlines;
 134         bool not_ws_added = false;
 135         for (const auto& el : m_children)
 136         {
 137             if(el->src_el()->is_inline())
 138             {
 139                 inlines.push_back(el);
 140                 if(!el->src_el()->is_white_space())
 141                     not_ws_added = true;
 142             } else
 143             {
 144                 if(not_ws_added)
 145                 {
 146                     auto anon_el = std::make_shared<html_tag>(src_el());
 147                     auto anon_ri = std::make_shared<render_item_block>(anon_el);
 148                     for(const auto& inl : inlines)
 149                     {
 150                         anon_ri->add_child(inl);
 151                     }
 152
 153                     not_ws_added = false;
 154                     new_children.push_back(anon_ri);
 155                     anon_ri->parent(ret);
 156                 }
 157                 new_children.push_back(el);
 158                 el->parent(ret);
 159                 inlines.clear();
 160             }
 161         }
 162         if(!inlines.empty() && not_ws_added)
 163         {
 164             auto anon_el = std::make_shared<html_tag>(src_el());
 165             auto anon_ri = std::make_shared<render_item_block>(anon_el);
 166             for(const auto& inl : inlines)
 167             {
 168                 anon_ri->add_child(inl);
 169             }
 170
 171             new_children.push_back(anon_ri);
 172             anon_ri->parent(ret);
 173         }
 174         ret->children() = new_children;
 175     }
 176
 177     if(!ret)
 178     {
 179         ret = std::make_shared<render_item_inline_context>(src_el());
 180         ret->parent(parent());
 181         ret->children() = children();
 182         for (const auto &el: ret->children())
 183         {
 184             el->parent(ret);
 185         }
 186     }
 187
 188     ret->src_el()->add_render(ret);
 189
 190     for(auto& el : ret->children())
 191     {
 192         el = el->init();
 193     }
 194
 195     return ret;
 196 }
 197
 198 int litehtml::render_item_block::_render(int x, int y, const containing_block_context &containing_block_size, formatting_context* fmt_ctx, bool second_pass)
 199 {
 200         containing_block_context self_size = calculate_containing_block_context(containing_block_size);
 201
 202     //*****************************************
 203     // Render content
 204     //*****************************************
 205         int ret_width = _render_content(x, y, second_pass, self_size, fmt_ctx);
 206     //*****************************************
 207
 208         bool requires_rerender = false;         // when true, the second pass for content rendering is required
 209
 210         // Set block width
 211         if(self_size.width.type == containing_block_context::cbc_value_type_absolute)
 212         {
 213                 ret_width = m_pos.width = self_size.render_width;
 214         } else if(self_size.width.type == containing_block_context::cbc_value_type_percentage)
 215         {
 216                 m_pos.width = self_size.render_width;
 217         } else
 218         {
 219                 m_pos.width = self_size.render_width;
 220         }
 221
 222         // Fix width with min-width attribute
 223         if(self_size.min_width.type != containing_block_context::cbc_value_type_none)
 224         {
 225                 if(m_pos.width < self_size.min_width)
 226                 {
 227                         m_pos.width = self_size.min_width;
 228                         requires_rerender = true;
 229                 }
 230         }
 231
 232         // Fix width with max-width attribute
 233         if(self_size.max_width.type != containing_block_context::cbc_value_type_none)
 234         {
 235                 if(m_pos.width > self_size.max_width)
 236                 {
 237                         m_pos.width = self_size.max_width;
 238                         requires_rerender = true;
 239                 }
 240         }
 241
 242         // re-render content with new width if required
 243         if (requires_rerender && !second_pass && !is_root())
 244         {
 245                 if(src_el()->is_block_formatting_context())
 246                 {
 247                         fmt_ctx->clear_floats(-1);
 248                 } else
 249                 {
 250                         fmt_ctx->clear_floats(self_size.context_idx);
 251                 }
 252
 253                 _render_content(x, y, true, self_size.new_width(m_pos.width), fmt_ctx);
 254         }
 255
 256         // Set block height
 257         if (self_size.height.type != containing_block_context::cbc_value_type_auto)
 258         {
 259                 if(self_size.height > 0)
 260                 {
 261                         m_pos.height = self_size.height;
 262                 }
 263                 if(src_el()->css().get_box_sizing() == box_sizing_border_box)
 264                 {
 265                         m_pos.height -= box_sizing_height();
 266                 }
 267         } else if (src_el()->is_block_formatting_context())
 268     {
 269                 // add the floats' height to the block height
 270         int floats_height = fmt_ctx->get_floats_height();
 271         if (floats_height > m_pos.height)
 272         {
 273             m_pos.height = floats_height;
 274         }
 275     }
 276
 277         // Fix height with min-height attribute
 278         if(self_size.min_height.type != containing_block_context::cbc_value_type_none)
 279         {
 280                 if(m_pos.height < self_size.min_height)
 281                 {
 282                         m_pos.height = self_size.min_height;
 283                 }
 284         }
 285
 286         // Fix width with max-width attribute
 287         if(self_size.max_height.type != containing_block_context::cbc_value_type_none)
 288         {
 289                 if(m_pos.height > self_size.max_height)
 290                 {
 291                         m_pos.height = self_size.max_height;
 292                 }
 293         }
 294
 295     // calculate the final position
 296     m_pos.move_to(x, y);
 297     m_pos.x += content_offset_left();
 298     m_pos.y += content_offset_top();
 299
 300     if (src_el()->css().get_display() == display_list_item)
 301     {
 302         string list_image = src_el()->css().get_list_style_image();
 303         if (!list_image.empty())
 304         {
 305             size sz;
 306             string list_image_baseurl = src_el()->css().get_list_style_image_baseurl();
 307             src_el()->get_document()->container()->get_image_size(list_image.c_str(), list_image_baseurl.c_str(), sz);
 308             if (m_pos.height < sz.height)
 309             {
 310                                 m_pos.height = sz.height;
 311             }
 312         }
 313
 314     }
 315
 316     return ret_width + content_offset_width();
 317 }