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(!(containing_block_size.size_mode & containing_block_context::size_mode_content))
 212         {
 213                 if(self_size.width.type == containing_block_context::cbc_value_type_absolute)
 214                 {
 215                         ret_width = m_pos.width = self_size.render_width;
 216                 } else
 217                 {
 218                         m_pos.width = self_size.render_width;
 219                 }
 220         } else
 221         {
 222                 m_pos.width = ret_width;
 223                 if(self_size.width.type == containing_block_context::cbc_value_type_absolute && ret_width > self_size.width)
 224                 {
 225                         ret_width = self_size.width;
 226                 }
 227         }
 228
 229         // Fix width with max-width attribute
 230         if(self_size.max_width.type != containing_block_context::cbc_value_type_none)
 231         {
 232                 if(m_pos.width > self_size.max_width)
 233                 {
 234                         m_pos.width = self_size.max_width;
 235                         requires_rerender = true;
 236                 }
 237         }
 238
 239         // Fix width with min-width attribute
 240         if(self_size.min_width.type != containing_block_context::cbc_value_type_none)
 241         {
 242                 if(m_pos.width < self_size.min_width)
 243                 {
 244                         m_pos.width = self_size.min_width;
 245                         requires_rerender = true;
 246                 }
 247         } else if(m_pos.width < 0)
 248         {
 249                 m_pos.width = 0;
 250         }
 251
 252         // re-render content with new width if required
 253         if (requires_rerender && !second_pass && !is_root())
 254         {
 255                 if(src_el()->is_block_formatting_context())
 256                 {
 257                         fmt_ctx->clear_floats(-1);
 258                 } else
 259                 {
 260                         fmt_ctx->clear_floats(self_size.context_idx);
 261                 }
 262
 263                 _render_content(x, y, true, self_size.new_width(m_pos.width), fmt_ctx);
 264         }
 265
 266         // Set block height
 267         if (self_size.height.type != containing_block_context::cbc_value_type_auto &&
 268             !(containing_block_size.size_mode & containing_block_context::size_mode_content))
 269         {
 270                 // TODO: Something wrong here
 271                 // Percentage height from undefined containing block height is usually <= 0
 272                 if(self_size.height.type == containing_block_context::cbc_value_type_percentage)
 273                 {
 274                         if (self_size.height > 0)
 275                         {
 276                                 m_pos.height = self_size.height;
 277                         }
 278                 } else
 279                 {
 280                         m_pos.height = self_size.height;
 281                 }
 282                 if (src_el()->css().get_box_sizing() == box_sizing_border_box)
 283                 {
 284                         m_pos.height -= box_sizing_height();
 285                 }
 286         } else if (src_el()->is_block_formatting_context())
 287         {
 288                 // add the floats' height to the block height
 289                 int floats_height = fmt_ctx->get_floats_height();
 290                 if (floats_height > m_pos.height)
 291                 {
 292                         m_pos.height = floats_height;
 293                 }
 294         }
 295         if(containing_block_size.size_mode & containing_block_context::size_mode_content)
 296         {
 297                 if(self_size.height.type == containing_block_context::cbc_value_type_absolute)
 298                 {
 299                         if(m_pos.height > self_size.height)
 300                         {
 301                                 m_pos.height = self_size.height;
 302                         }
 303                 }
 304         }
 305
 306         // Fix height with min-height attribute
 307         if(self_size.min_height.type != containing_block_context::cbc_value_type_none)
 308         {
 309                 if(m_pos.height < self_size.min_height)
 310                 {
 311                         m_pos.height = self_size.min_height;
 312                 }
 313         } else if(m_pos.height < 0)
 314         {
 315                 m_pos.height = 0;
 316         }
 317
 318         // Fix width with max-width attribute
 319         if(self_size.max_height.type != containing_block_context::cbc_value_type_none)
 320         {
 321                 if(m_pos.height > self_size.max_height)
 322                 {
 323                         m_pos.height = self_size.max_height;
 324                 }
 325         }
 326
 327     // calculate the final position
 328     m_pos.move_to(x, y);
 329     m_pos.x += content_offset_left();
 330     m_pos.y += content_offset_top();
 331
 332     if (src_el()->css().get_display() == display_list_item)
 333     {
 334         string list_image = src_el()->css().get_list_style_image();
 335         if (!list_image.empty())
 336         {
 337             size sz;
 338             string list_image_baseurl = src_el()->css().get_list_style_image_baseurl();
 339             src_el()->get_document()->container()->get_image_size(list_image.c_str(), list_image_baseurl.c_str(), sz);
 340             if (m_pos.height < sz.height)
 341             {
 342                                 m_pos.height = sz.height;
 343             }
 344         }
 345
 346     }
 347
 348     return ret_width + content_offset_width();
 349 }