src/plugins/litehtml_viewer/litehtml/flex_item.cpp

   1 #include "html.h"
   2 #include "flex_item.h"
   3 #include "render_item.h"
   4 #include "flex_line.h"
   5 #include <cmath>
   6
   7 void litehtml::flex_item::init(const litehtml::containing_block_context &self_size,
   8                                                            litehtml::formatting_context *fmt_ctx, flex_align_items align_items)
   9 {
  10         grow = (int) std::nearbyint(el->css().get_flex_grow() * 1000.0);
  11         // Negative numbers are invalid.
  12         // https://www.w3.org/TR/css-flexbox-1/#valdef-flex-grow-number
  13         if(grow < 0) grow = 0;
  14
  15         shrink = (int) std::nearbyint(el->css().get_flex_shrink() * 1000.0);
  16         // Negative numbers are invalid.
  17         // https://www.w3.org/TR/css-flexbox-1/#valdef-flex-shrink-number
  18         if(shrink < 0) shrink = 1000;
  19
  20         el->calc_outlines(self_size.render_width);
  21         order = el->css().get_order();
  22
  23         direction_specific_init(self_size, fmt_ctx);
  24
  25         if (el->css().get_flex_align_self() == flex_align_items_auto)
  26         {
  27                 align = align_items;
  28         } else
  29         {
  30                 align = el->css().get_flex_align_self();
  31         }
  32         main_size = base_size;
  33         scaled_flex_shrink_factor = base_size * shrink;
  34         frozen = false;
  35 }
  36
  37 void litehtml::flex_item::place(flex_line &ln, int main_pos,
  38                                                                 const containing_block_context &self_size,
  39                                                                 formatting_context *fmt_ctx)
  40 {
  41         apply_main_auto_margins();
  42         set_main_position(main_pos);
  43         if(!apply_cross_auto_margins(ln.cross_size))
  44         {
  45                 switch (align & 0xFF)
  46                 {
  47                         case flex_align_items_baseline:
  48                                 align_baseline(ln, self_size, fmt_ctx);
  49                                 break;
  50                         case flex_align_items_flex_end:
  51                                 if(ln.reverse_cross)
  52                                 {
  53                                         set_cross_position(ln.cross_start);
  54                                         break;  /// If cross axis is reversed position item from start
  55                                 }
  56                         case flex_align_items_end:
  57                                 set_cross_position(ln.cross_start + ln.cross_size - get_el_cross_size());
  58                                 break;
  59                         case flex_align_items_center:
  60                                 set_cross_position(ln.cross_start + ln.cross_size / 2 - get_el_cross_size() / 2);
  61                                 break;
  62                         case flex_align_items_flex_start:
  63                                 if(ln.reverse_cross)    /// If cross axis is reversed position item from end
  64                                 {
  65                                         set_cross_position(ln.cross_start + ln.cross_size - get_el_cross_size());
  66                                         break;
  67                                 }
  68                         case flex_align_items_start:
  69                                 set_cross_position(ln.cross_start);
  70                                 break;
  71                         default:
  72                                 align_stretch(ln, self_size, fmt_ctx);
  73                                 break;
  74                 }
  75         }
  76 }
  77
  78 int litehtml::flex_item::get_last_baseline(baseline::_baseline_type type) const
  79 {
  80         if(type == baseline::baseline_type_top)
  81         {
  82                 return el->get_last_baseline();
  83         } else if(type == baseline::baseline_type_bottom)
  84         {
  85                 return el->height() - el->get_last_baseline();
  86         }
  87         return 0;
  88 }
  89
  90 int litehtml::flex_item::get_first_baseline(litehtml::baseline::_baseline_type type) const
  91 {
  92         if(type == baseline::baseline_type_top)
  93         {
  94                 return el->get_first_baseline();
  95         } else if(type == baseline::baseline_type_bottom)
  96         {
  97                 return el->height() - el->get_first_baseline();
  98         }
  99         return 0;
 100 }
 101
 102
 103 ////////////////////////////////////////////////////////////////////////////////////
 104
 105 void litehtml::flex_item_row_direction::direction_specific_init(const litehtml::containing_block_context &self_size,
 106                                                                                                                                 litehtml::formatting_context *fmt_ctx)
 107 {
 108         if(el->css().get_margins().left.is_predefined())
 109         {
 110                 auto_margin_main_start = 0;
 111         }
 112         if(el->css().get_margins().right.is_predefined())
 113         {
 114                 auto_margin_main_end = 0;
 115         }
 116         if(el->css().get_margins().top.is_predefined())
 117         {
 118                 auto_margin_cross_start = true;
 119         }
 120         if(el->css().get_margins().bottom.is_predefined())
 121         {
 122                 auto_margin_cross_end = true;
 123         }
 124         def_value<int> content_size(0);
 125         if (el->css().get_min_width().is_predefined())
 126         {
 127                 min_size = el->render(0, 0,
 128                                                           self_size.new_width(el->content_offset_width(),
 129                                                                                                   containing_block_context::size_mode_content), fmt_ctx);
 130                 content_size = min_size;
 131         } else
 132         {
 133                 min_size = el->css().get_min_width().calc_percent(self_size.render_width) +
 134                                    el->content_offset_width();
 135         }
 136         if (!el->css().get_max_width().is_predefined())
 137         {
 138                 max_size = el->css().get_max_width().calc_percent(self_size.render_width) +
 139                                    el->content_offset_width();
 140         }
 141         bool flex_basis_predefined = el->css().get_flex_basis().is_predefined();
 142         int predef = flex_basis_auto;
 143         if(flex_basis_predefined)
 144         {
 145                 predef = el->css().get_flex_basis().predef();
 146         } else
 147         {
 148                 if(el->css().get_flex_basis().val() < 0)
 149                 {
 150                         flex_basis_predefined = true;
 151                 }
 152         }
 153
 154         if (flex_basis_predefined)
 155         {
 156                 switch (predef)
 157                 {
 158                         case flex_basis_auto:
 159                                 if (!el->css().get_width().is_predefined())
 160                                 {
 161                                         base_size = el->css().get_width().calc_percent(self_size.render_width) +
 162                                                                 el->content_offset_width();
 163                                         break;
 164                                 }
 165                                 // if width is not predefined, use content size as base size
 166                         case flex_basis_fit_content:
 167                         case flex_basis_content:
 168                                 base_size = el->render(0, 0, self_size.new_width(self_size.render_width + el->content_offset_width(),
 169                                                                                                                                  containing_block_context::size_mode_content |
 170                                                                                                                                  containing_block_context::size_mode_exact_width),
 171                                                                            fmt_ctx);
 172                                 break;
 173                         case flex_basis_min_content:
 174                                 if(content_size.is_default())
 175                                 {
 176                                         content_size = el->render(0, 0,
 177                                                                                           self_size.new_width(el->content_offset_width(),
 178                                                                                                                                   containing_block_context::size_mode_content),
 179                                                                                           fmt_ctx);
 180                                 }
 181                                 base_size = content_size;
 182                                 break;
 183                         case flex_basis_max_content:
 184                                 el->render(0, 0, self_size, fmt_ctx);
 185                                 base_size = el->width();
 186                                 break;
 187                         default:
 188                                 base_size = 0;
 189                                 break;
 190                 }
 191         } else
 192         {
 193                 base_size = el->css().get_flex_basis().calc_percent(self_size.render_width) +
 194                                         el->content_offset_width();
 195                 base_size = std::max(base_size, min_size);
 196         }
 197 }
 198
 199 void litehtml::flex_item_row_direction::apply_main_auto_margins()
 200 {
 201         // apply auto margins to item
 202         if(!auto_margin_main_start.is_default())
 203         {
 204                 el->get_margins().left = auto_margin_main_start;
 205                 el->pos().x += auto_margin_main_start;
 206         }
 207         if(!auto_margin_main_end.is_default()) el->get_margins().right = auto_margin_main_end;
 208 }
 209
 210 bool litehtml::flex_item_row_direction::apply_cross_auto_margins(int cross_size)
 211 {
 212         if(auto_margin_cross_end || auto_margin_cross_start)
 213         {
 214                 int margins_num = 0;
 215                 if(auto_margin_cross_end)
 216                 {
 217                         margins_num++;
 218                 }
 219                 if(auto_margin_cross_start)
 220                 {
 221                         margins_num++;
 222                 }
 223                 int margin = (cross_size - el->height()) / margins_num;
 224                 if(auto_margin_cross_start)
 225                 {
 226                         el->get_margins().top = margin;
 227                         el->pos().y = el->content_offset_top();
 228                 }
 229                 if(auto_margin_cross_end)
 230                 {
 231                         el->get_margins().bottom = margin;
 232                 }
 233                 return true;
 234         }
 235         return false;
 236 }
 237
 238 void litehtml::flex_item_row_direction::set_main_position(int pos)
 239 {
 240         el->pos().x = pos + el->content_offset_left();
 241 }
 242
 243 void litehtml::flex_item_row_direction::set_cross_position(int pos)
 244 {
 245         el->pos().y = pos + el->content_offset_top();
 246 }
 247
 248 void litehtml::flex_item_row_direction::align_stretch(flex_line &ln, const containing_block_context &self_size,
 249                                                                                                           formatting_context *fmt_ctx)
 250 {
 251         set_cross_position(ln.cross_start);
 252         if (el->css().get_height().is_predefined())
 253         {
 254                 el->render(el->left(), el->top(), self_size.new_width_height(
 255                                 el->pos().width + el->box_sizing_width(),
 256                                 ln.cross_size - el->content_offset_height() + el->box_sizing_height(),
 257                                 containing_block_context::size_mode_exact_width |
 258                                 containing_block_context::size_mode_exact_height
 259                                 ), fmt_ctx);
 260                 apply_main_auto_margins();
 261         }
 262 }
 263
 264 void litehtml::flex_item_row_direction::align_baseline(litehtml::flex_line &ln,
 265                                                                                                            const containing_block_context &self_size,
 266                                                                                                            formatting_context *fmt_ctx)
 267 {
 268         if (align & flex_align_items_last)
 269         {
 270                 set_cross_position(ln.cross_start + ln.last_baseline.get_offset_from_top(ln.cross_size) - el->get_last_baseline());
 271         } else
 272         {
 273                 set_cross_position(ln.cross_start + ln.first_baseline.get_offset_from_top(ln.cross_size) - el->get_first_baseline());
 274         }
 275 }
 276
 277 int litehtml::flex_item_row_direction::get_el_main_size()
 278 {
 279         return el->width();
 280 }
 281
 282 int litehtml::flex_item_row_direction::get_el_cross_size()
 283 {
 284         return el->height();
 285 }
 286
 287 ////////////////////////////////////////////////////////////////////////////////////
 288
 289 void litehtml::flex_item_column_direction::direction_specific_init(const litehtml::containing_block_context &self_size,
 290                                                                                                                                    litehtml::formatting_context *fmt_ctx)
 291 {
 292         if(el->css().get_margins().top.is_predefined())
 293         {
 294                 auto_margin_main_start = 0;
 295         }
 296         if(el->css().get_margins().bottom.is_predefined())
 297         {
 298                 auto_margin_main_end = 0;
 299         }
 300         if(el->css().get_margins().left.is_predefined())
 301         {
 302                 auto_margin_cross_start = true;
 303         }
 304         if(el->css().get_margins().right.is_predefined())
 305         {
 306                 auto_margin_cross_end = true;
 307         }
 308         if (el->css().get_min_height().is_predefined())
 309         {
 310                 el->render(0, 0, self_size.new_width(self_size.render_width, containing_block_context::size_mode_content), fmt_ctx);
 311                 min_size = el->height();
 312         } else
 313         {
 314                 min_size = el->css().get_min_height().calc_percent(self_size.height) +
 315                                    el->content_offset_height();
 316         }
 317         if (!el->css().get_max_height().is_predefined())
 318         {
 319                 max_size = el->css().get_max_height().calc_percent(self_size.height) +
 320                                    el->content_offset_width();
 321         }
 322
 323         bool flex_basis_predefined = el->css().get_flex_basis().is_predefined();
 324         int predef = flex_basis_auto;
 325         if(flex_basis_predefined)
 326         {
 327                 predef = el->css().get_flex_basis().predef();
 328         } else
 329         {
 330                 if(el->css().get_flex_basis().val() < 0)
 331                 {
 332                         flex_basis_predefined = true;
 333                 }
 334         }
 335
 336         if (flex_basis_predefined)
 337         {
 338                 switch (predef)
 339                 {
 340                         case flex_basis_auto:
 341                                 if (!el->css().get_height().is_predefined())
 342                                 {
 343                                         base_size = el->css().get_height().calc_percent(self_size.height) +
 344                                                                 el->content_offset_height();
 345                                         break;
 346                                 }
 347                         case flex_basis_max_content:
 348                         case flex_basis_fit_content:
 349                                 el->render(0, 0, self_size, fmt_ctx);
 350                                 base_size = el->height();
 351                                 break;
 352                         case flex_basis_min_content:
 353                                 base_size = min_size;
 354                                 break;
 355                         default:
 356                                 base_size = 0;
 357                 }
 358         } else
 359         {
 360                 if(el->css().get_flex_basis().units() == css_units_percentage)
 361                 {
 362                         if(self_size.height.type == containing_block_context::cbc_value_type_absolute)
 363                         {
 364                                 base_size = el->css().get_flex_basis().calc_percent(self_size.height) +
 365                                                         el->content_offset_height();
 366                         } else
 367                         {
 368                                 base_size = 0;
 369                         }
 370                 } else
 371                 {
 372                         base_size = (int) el->css().get_flex_basis().val() + el->content_offset_height();
 373                 }
 374                 base_size = std::max(base_size, min_size);
 375         }
 376 }
 377
 378 void litehtml::flex_item_column_direction::apply_main_auto_margins()
 379 {
 380         // apply auto margins to item
 381         if(!auto_margin_main_start.is_default())
 382         {
 383                 el->get_margins().top = auto_margin_main_start;
 384                 el->pos().y += auto_margin_main_start;
 385         }
 386         if(!auto_margin_main_end.is_default()) el->get_margins().bottom = auto_margin_main_end;
 387 }
 388
 389 bool litehtml::flex_item_column_direction::apply_cross_auto_margins(int cross_size)
 390 {
 391         if(auto_margin_cross_end || auto_margin_cross_start)
 392         {
 393                 int margins_num = 0;
 394                 if(auto_margin_cross_end)
 395                 {
 396                         margins_num++;
 397                 }
 398                 if(auto_margin_cross_start)
 399                 {
 400                         margins_num++;
 401                 }
 402                 int margin = (cross_size - el->width()) / margins_num;
 403                 if(auto_margin_cross_start)
 404                 {
 405                         el->get_margins().left = margin;
 406                         el->pos().x += el->content_offset_left();
 407                 }
 408                 if(auto_margin_cross_end)
 409                 {
 410                         el->get_margins().right = margin;
 411                 }
 412         }
 413         return false;
 414 }
 415
 416 void litehtml::flex_item_column_direction::set_main_position(int pos)
 417 {
 418         el->pos().y = pos + el->content_offset_top();
 419 }
 420
 421 void litehtml::flex_item_column_direction::set_cross_position(int pos)
 422 {
 423         el->pos().x = pos + el->content_offset_left();
 424 }
 425
 426 void litehtml::flex_item_column_direction::align_stretch(flex_line &ln, const containing_block_context &self_size,
 427                                                                                                                  formatting_context *fmt_ctx)
 428 {
 429         /// MAIN:  Y
 430         /// CROSS: X
 431         if (!el->css().get_width().is_predefined())
 432         {
 433                 el->render(ln.cross_start,
 434                                    el->pos().y - el->content_offset_top(),
 435                                    self_size.new_width_height(ln.cross_size - el->content_offset_width() + el->box_sizing_width(),
 436                                                                                           main_size - el->content_offset_height() + el->box_sizing_height(),
 437                                                                                           containing_block_context::size_mode_exact_height),
 438                                    fmt_ctx, false);
 439         } else
 440         {
 441                 el->render(ln.cross_start,
 442                                    el->pos().y - el->content_offset_top(),
 443                                    self_size.new_width_height(
 444                                                    ln.cross_size - el->content_offset_width() + el->box_sizing_width(),
 445                                                    main_size - el->content_offset_height() + el->box_sizing_height(),
 446                                                    containing_block_context::size_mode_exact_width |
 447                                                    containing_block_context::size_mode_exact_height),
 448                                    fmt_ctx, false);
 449         }
 450         /// Apply auto margins after rendering
 451         apply_main_auto_margins();
 452 }
 453
 454 void litehtml::flex_item_column_direction::align_baseline(litehtml::flex_line &ln,
 455                                                                                                                   const containing_block_context &self_size,
 456                                                                                                                   formatting_context *fmt_ctx)
 457 {
 458         // The fallback alignment for first baseline is start, the one for last baseline is end.
 459         if(align & flex_align_items_last)
 460         {
 461                 if(ln.reverse_cross)
 462                 {
 463                         set_cross_position(ln.cross_start);
 464                 } else
 465                 {
 466                         set_cross_position(ln.cross_start + ln.cross_size - get_el_cross_size());
 467                 }
 468         } else
 469         {
 470                 if(!ln.reverse_cross)
 471                 {
 472                         set_cross_position(ln.cross_start);
 473                 } else
 474                 {
 475                         set_cross_position(ln.cross_start + ln.cross_size - get_el_cross_size());
 476                 }
 477         }
 478 }
 479
 480 int litehtml::flex_item_column_direction::get_el_main_size()
 481 {
 482         return el->height();
 483 }
 484
 485 int litehtml::flex_item_column_direction::get_el_cross_size()
 486 {
 487         return el->width();
 488 }