src/plugins/litehtml_viewer/litehtml/line_box.cpp

   1 #include "html.h"
   2 #include "line_box.h"
   3 #include "element.h"
   4 #include "render_item.h"
   5 #include <algorithm>
   6
   7 //////////////////////////////////////////////////////////////////////////////////////////
   8
   9 void litehtml::line_box_item::place_to(int x, int y)
  10 {
  11         m_element->pos().x = x + m_element->content_offset_left();
  12         m_element->pos().y = y + m_element->content_offset_top();
  13 }
  14
  15 litehtml::position& litehtml::line_box_item::pos()
  16 {
  17         return m_element->pos();
  18 }
  19
  20
  21 int litehtml::line_box_item::width() const
  22 {
  23         return m_element->width();
  24 }
  25
  26 int litehtml::line_box_item::top() const
  27 {
  28         return m_element->top();
  29 }
  30
  31 int litehtml::line_box_item::bottom() const
  32 {
  33         return m_element->bottom();
  34 }
  35
  36 int litehtml::line_box_item::right() const
  37 {
  38         return m_element->right();
  39 }
  40
  41 int litehtml::line_box_item::left() const
  42 {
  43         return m_element->left();
  44 }
  45
  46 //////////////////////////////////////////////////////////////////////////////////////////
  47
  48 litehtml::lbi_start::lbi_start(const std::shared_ptr<render_item>& element) : line_box_item(element)
  49 {
  50         m_pos.height = m_element->src_el()->css().get_font_metrics().height;
  51         m_pos.width = m_element->content_offset_left();
  52 }
  53
  54 void litehtml::lbi_start::place_to(int x, int y)
  55 {
  56         m_pos.x = x + m_element->content_offset_left();
  57         m_pos.y = y;
  58 }
  59
  60 int litehtml::lbi_start::width() const
  61 {
  62         return m_pos.width;
  63 }
  64
  65 int litehtml::lbi_start::top() const
  66 {
  67         return m_pos.y;
  68 }
  69
  70 int litehtml::lbi_start::bottom() const
  71 {
  72         return m_pos.y + m_pos.height;
  73 }
  74
  75 int litehtml::lbi_start::right() const
  76 {
  77         return m_pos.x;
  78 }
  79
  80 int litehtml::lbi_start::left() const
  81 {
  82         return m_pos.x - m_element->content_offset_left();
  83 }
  84
  85 //////////////////////////////////////////////////////////////////////////////////////////
  86
  87 litehtml::lbi_end::lbi_end(const std::shared_ptr<render_item>& element) : lbi_start(element)
  88 {
  89         m_pos.height = m_element->src_el()->css().get_font_metrics().height;
  90         m_pos.width = m_element->content_offset_right();
  91 }
  92
  93 void litehtml::lbi_end::place_to(int x, int y)
  94 {
  95         m_pos.x = x;
  96         m_pos.y = y;
  97 }
  98
  99 int litehtml::lbi_end::right() const
 100 {
 101         return m_pos.x + m_pos.width;
 102 }
 103
 104 int litehtml::lbi_end::left() const
 105 {
 106         return m_pos.x;
 107 }
 108
 109 //////////////////////////////////////////////////////////////////////////////////////////
 110
 111 litehtml::lbi_continue::lbi_continue(const std::shared_ptr<render_item>& element) : lbi_start(element)
 112 {
 113         m_pos.height = m_element->src_el()->css().get_font_metrics().height;
 114         m_pos.width = 0;
 115 }
 116
 117 void litehtml::lbi_continue::place_to(int x, int y)
 118 {
 119         m_pos.x = x;
 120         m_pos.y = y;
 121 }
 122
 123 int litehtml::lbi_continue::right() const
 124 {
 125         return m_pos.x;
 126 }
 127
 128 int litehtml::lbi_continue::left() const
 129 {
 130         return m_pos.x;
 131 }
 132
 133 int litehtml::lbi_continue::width() const
 134 {
 135         return 0;
 136 }
 137
 138 //////////////////////////////////////////////////////////////////////////////////////////
 139
 140 void litehtml::line_box::add_item(std::unique_ptr<line_box_item> item)
 141 {
 142     item->get_el()->skip(false);
 143     bool add    = true;
 144         switch (item->get_type())
 145         {
 146                 case line_box_item::type_text_part:
 147                         if(item->get_el()->src_el()->is_white_space())
 148                         {
 149                                 add = !is_empty() && !have_last_space();
 150                         }
 151                         break;
 152                 case line_box_item::type_inline_start:
 153                 case line_box_item::type_inline_end:
 154                 case line_box_item::type_inline_continue:
 155                         add = true;
 156                         break;
 157         }
 158         if(add)
 159         {
 160                 item->place_to(m_left + m_width, m_top);
 161                 m_width += item->width();
 162                 m_height = std::max(m_height, item->get_el()->height());
 163                 m_items.emplace_back(std::move(item));
 164         } else
 165         {
 166                 item->get_el()->skip(true);
 167         }
 168 }
 169
 170 int litehtml::line_box::calc_va_baseline(const va_context& current, vertical_align va, const font_metrics& new_font, int top, int bottom)
 171 {
 172         switch(va)
 173         {
 174                 case va_super:
 175                         return current.baseline - current.fm.height / 3;
 176                 case va_sub:
 177                         return current.baseline + current.fm.height / 3;
 178                 case va_middle:
 179                         return current.baseline - current.fm.x_height / 2;
 180                 case va_text_top:
 181                         return current.baseline - (current.fm.height - current.fm.base_line()) +
 182                                                                                 new_font.height - new_font.base_line();
 183                 case va_text_bottom:
 184                         return current.baseline + current.fm.base_line() - new_font.base_line();
 185                 case va_top:
 186                         return top + new_font.height - new_font.base_line();
 187                 case va_bottom:
 188                         return bottom - new_font.height + new_font.base_line();
 189                 default:
 190                         return current.baseline;
 191         }
 192 }
 193
 194 std::list< std::unique_ptr<litehtml::line_box_item> > litehtml::line_box::finish(bool last_box, const containing_block_context &containing_block_size)
 195 {
 196         std::list< std::unique_ptr<line_box_item> > ret_items;
 197
 198         if(!last_box)
 199         {
 200                 while(!m_items.empty())
 201                 {
 202                         if (m_items.back()->get_type() == line_box_item::type_text_part)
 203                         {
 204                                 // remove trailing spaces
 205                                 if (m_items.back()->get_el()->src_el()->is_break() ||
 206                                         m_items.back()->get_el()->src_el()->is_white_space())
 207                                 {
 208                                         m_width -= m_items.back()->width();
 209                                         m_items.back()->get_el()->skip(true);
 210                                         m_items.pop_back();
 211                                 } else
 212                                 {
 213                                         break;
 214                                 }
 215                         } else if (m_items.back()->get_type() == line_box_item::type_inline_start)
 216                         {
 217                                 // remove trailing empty inline_start markers
 218                                 // these markers will be added at the beginning of the next line box
 219                                 m_width -= m_items.back()->width();
 220                                 ret_items.emplace_back(std::move(m_items.back()));
 221                                 m_items.pop_back();
 222                         } else
 223                         {
 224                                 break;
 225                         }
 226                 }
 227         } else
 228         {
 229                 // remove trailing spaces
 230                 auto iter = m_items.rbegin();
 231                 while(iter != m_items.rend())
 232                 {
 233                         if ((*iter)->get_type() == line_box_item::type_text_part)
 234                         {
 235                                 if((*iter)->get_el()->src_el()->is_white_space())
 236                                 {
 237                                         (*iter)->get_el()->skip(true);
 238                                         m_width -= (*iter)->width();
 239                                         // Space can be between text and inline_end marker
 240                                         // We have to shift all items on the right side
 241                                         if(iter != m_items.rbegin())
 242                                         {
 243                                                 auto r_iter = iter;
 244                                                 r_iter--;
 245                                                 while (true)
 246                                                 {
 247                                                         (*r_iter)->pos().x -= (*iter)->width();
 248                                                         if (r_iter == m_items.rbegin())
 249                                                         {
 250                                                                 break;
 251                                                         }
 252                                                         r_iter--;
 253                                                 }
 254                                         }
 255                                         // erase white space element
 256                                         iter = decltype(iter) (m_items.erase( std::next(iter).base() ));
 257                                 } else
 258                                 {
 259                                         break;
 260                                 }
 261                         } else
 262                         {
 263                                 iter++;
 264                         }
 265                 }
 266         }
 267
 268     if( is_empty() || (!is_empty() && last_box && is_break_only()) )
 269     {
 270         m_height = m_default_line_height;
 271                 m_baseline = m_font_metrics.base_line();
 272         return ret_items;
 273     }
 274
 275     int spc_x = 0;
 276
 277     int add_x = 0;
 278     switch(m_text_align)
 279     {
 280         case text_align_right:
 281             if(m_width < (m_right - m_left))
 282             {
 283                 add_x = (m_right - m_left) - m_width;
 284             }
 285             break;
 286         case text_align_center:
 287             if(m_width < (m_right - m_left))
 288             {
 289                 add_x = ((m_right - m_left) - m_width) / 2;
 290             }
 291             break;
 292         case text_align_justify:
 293             if (m_width < (m_right - m_left))
 294             {
 295                 add_x = 0;
 296                 spc_x = (m_right - m_left) - m_width;
 297                 if (spc_x > m_width/4)
 298                     spc_x = 0;
 299             }
 300             break;
 301         default:
 302             add_x = 0;
 303     }
 304
 305     int counter = 0;
 306     float offj  = float(spc_x) / std::max(1.f, float(m_items.size())-1.f);
 307     float cixx  = 0.0f;
 308
 309     int line_top        = 0;
 310     int line_bottom     = 0;
 311
 312         va_context current_context;
 313         std::list<va_context> contexts;
 314
 315         current_context.baseline = 0;
 316         current_context.fm = m_font_metrics;
 317
 318         m_min_width = 0;
 319
 320     for (const auto& lbi : m_items)
 321     {
 322                 m_min_width += lbi->get_rendered_min_width();
 323                 { // start text_align_justify
 324                         if (spc_x && counter)
 325                         {
 326                                 cixx += offj;
 327                                 if ((counter + 1) == int(m_items.size()))
 328                                         cixx += 0.99f;
 329                                 lbi->pos().x += int(cixx);
 330                         }
 331                         counter++;
 332                         if ((m_text_align == text_align_right || spc_x) && counter == int(m_items.size()))
 333                         {
 334                                 // Forcible justify the last element to the right side for text align right and justify;
 335                                 lbi->pos().x = m_right - lbi->pos().width;
 336                         } else if (add_x)
 337                         {
 338                                 lbi->pos().x += add_x;
 339                         }
 340                 } // end text_align_justify
 341
 342                 if (lbi->get_type() == line_box_item::type_inline_start || lbi->get_type() == line_box_item::type_inline_continue)
 343                 {
 344                         contexts.push_back(current_context);
 345                         current_context.baseline = calc_va_baseline(current_context,
 346                                                                                                                 lbi->get_el()->css().get_vertical_align(),
 347                                                                                                                 lbi->get_el()->css().get_font_metrics(),
 348                                                                                                                 line_top, line_bottom);
 349                         current_context.fm = lbi->get_el()->css().get_font_metrics();
 350                 }
 351
 352                 // Align elements vertically by baseline.
 353         if(lbi->get_el()->src_el()->css().get_display() == display_inline_text || lbi->get_el()->src_el()->css().get_display() == display_inline)
 354         {
 355                         // inline elements and text are aligned by baseline only
 356                         // at this point the baseline for text is properly aligned already
 357                         lbi->pos().y = current_context.baseline - lbi->get_el()->css().get_font_metrics().height + lbi->get_el()->css().get_font_metrics().base_line();
 358         } else
 359         {
 360             switch(lbi->get_el()->css().get_vertical_align())
 361             {
 362                                 case va_sub:
 363                 case va_super:
 364                                         {
 365                                                 int bl = calc_va_baseline(current_context, lbi->get_el()->css().get_vertical_align(), current_context.fm, line_top, line_bottom);
 366                                                 lbi->pos().y = bl - lbi->get_el()->height() + lbi->get_el()->get_base_line() +
 367                                                                 lbi->get_el()->content_offset_top();
 368                                         }
 369                                         break;
 370                                 case va_bottom:
 371                                         lbi->pos().y = line_bottom - lbi->get_el()->height() + lbi->get_el()->content_offset_top();
 372                                         break;
 373                                 case va_top:
 374                                         lbi->pos().y = line_top + lbi->get_el()->content_offset_top();
 375                                         break;
 376                 case va_baseline:
 377                                         lbi->pos().y = current_context.baseline - lbi->get_el()->height() + lbi->get_el()->get_base_line() +
 378                                                         lbi->get_el()->content_offset_top();
 379                     break;
 380                 case va_text_top:
 381                                         lbi->pos().y = current_context.baseline - current_context.fm.height + current_context.fm.base_line() +
 382                                                         lbi->get_el()->content_offset_top();
 383                     break;
 384                                 case va_text_bottom:
 385                                         lbi->pos().y = current_context.baseline + current_context.fm.base_line() - lbi->get_el()->height() +
 386                                                         lbi->get_el()->content_offset_top();
 387                                         break;
 388                 case va_middle:
 389                                         lbi->pos().y = current_context.baseline - current_context.fm.x_height / 2 - lbi->get_el()->height() / 2 +
 390                                                         lbi->get_el()->content_offset_top();
 391                     break;
 392             }
 393         }
 394
 395                 if (lbi->get_type() == line_box_item::type_inline_end)
 396                 {
 397                         if(!contexts.empty())
 398                         {
 399                                 current_context = contexts.back();
 400                                 contexts.pop_back();
 401                         }
 402                 }
 403
 404                 // calculate line height
 405                 line_top = std::min(line_top, lbi->top());
 406                 line_bottom = std::max(line_bottom, lbi->bottom());
 407
 408                 if(lbi->get_el()->src_el()->css().get_display() == display_inline_text)
 409                 {
 410                         m_line_height = std::max(m_line_height, lbi->get_el()->css().get_line_height());
 411                 }
 412     }
 413
 414         m_height = line_bottom - line_top;
 415         int top_shift = line_top;
 416         if(m_height < m_line_height)
 417         {
 418                 top_shift -= (m_line_height - m_height) / 2;
 419                 m_height = m_line_height;
 420         }
 421         m_baseline = line_bottom;
 422
 423         struct inline_item_box
 424         {
 425                 std::shared_ptr<render_item> element;
 426                 position box;
 427
 428                 inline_item_box() = default;
 429                 explicit inline_item_box(const std::shared_ptr<render_item>& el) : element(el) {}
 430         };
 431
 432         std::list<inline_item_box> inlines;
 433
 434         contexts.clear();
 435
 436         current_context.baseline = 0;
 437         current_context.fm = m_font_metrics;
 438         bool va_top_bottom = false;
 439
 440     for (const auto& lbi : m_items)
 441     {
 442                 // Calculate baseline. Now we calculate baseline for vertical alignment top and bottom
 443                 if (lbi->get_type() == line_box_item::type_inline_start || lbi->get_type() == line_box_item::type_inline_continue)
 444                 {
 445                         contexts.push_back(current_context);
 446                         va_top_bottom = lbi->get_el()->css().get_vertical_align() == va_bottom || lbi->get_el()->css().get_vertical_align() == va_top;
 447                         current_context.baseline = calc_va_baseline(current_context,
 448                                                                                                                 lbi->get_el()->css().get_vertical_align(),
 449                                                                                                                 lbi->get_el()->css().get_font_metrics(),
 450                                                                                                                 top_shift, top_shift + m_height);
 451                         current_context.fm = lbi->get_el()->css().get_font_metrics();
 452                 }
 453
 454                 // Align inlines and text by baseline if current vertical alignment is top or bottom
 455                 if(va_top_bottom)
 456                 {
 457                         if (lbi->get_el()->src_el()->css().get_display() == display_inline_text ||
 458                                 lbi->get_el()->src_el()->css().get_display() == display_inline)
 459                         {
 460                                 // inline elements and text are aligned by baseline only
 461                                 // at this point the baseline for text is properly aligned already
 462                                 lbi->pos().y = current_context.baseline - lbi->get_el()->css().get_font_metrics().height +
 463                                                            lbi->get_el()->css().get_font_metrics().base_line();
 464                         }
 465                 }
 466
 467                 // Pop the prev context
 468                 if (lbi->get_type() == line_box_item::type_inline_end)
 469                 {
 470                         if(!contexts.empty())
 471                         {
 472                                 current_context = contexts.back();
 473                                 contexts.pop_back();
 474                         }
 475                 }
 476
 477                 // move element to the correct position
 478                 lbi->pos().y += m_top - top_shift;
 479
 480                 // Perform vertical align top and bottom for inline boxes
 481         if(lbi->get_el()->css().get_display() != display_inline_text && lbi->get_el()->css().get_display() != display_inline)
 482         {
 483             if(lbi->get_el()->css().get_vertical_align() == va_top)
 484                         {
 485                                 lbi->pos().y = m_top + lbi->get_el()->content_offset_top();
 486                         } else if(lbi->get_el()->css().get_vertical_align() == va_bottom)
 487                         {
 488                                 lbi->pos().y = m_top + m_height - lbi->get_el()->height() + lbi->get_el()->content_offset_top();
 489                         }
 490         }
 491         lbi->get_el()->apply_relative_shift(containing_block_size);
 492
 493                 // Calculate and push inline box into the render item element
 494                 if(lbi->get_type() == line_box_item::type_inline_start || lbi->get_type() == line_box_item::type_inline_continue)
 495                 {
 496                         if(lbi->get_type() == line_box_item::type_inline_start)
 497                         {
 498                                 lbi->get_el()->clear_inline_boxes();
 499                         }
 500                         inlines.emplace_back(lbi->get_el());
 501                         inlines.back().box.x = lbi->left();
 502                         inlines.back().box.y = lbi->top() - lbi->get_el()->content_offset_top();
 503                         inlines.back().box.height = lbi->bottom() - lbi->top() + lbi->get_el()->content_offset_height();
 504                 } else if(lbi->get_type() == line_box_item::type_inline_end)
 505                 {
 506                         if(!inlines.empty())
 507                         {
 508                                 inlines.back().box.width = lbi->right() - inlines.back().box.x;
 509                                 inlines.back().element->add_inline_box(inlines.back().box);
 510                                 inlines.pop_back();
 511                         }
 512                 }
 513     }
 514
 515         for(auto iter = inlines.rbegin(); iter != inlines.rend(); ++iter)
 516         {
 517                 iter->box.width =  m_items.back()->right() - iter->box.x;
 518                 iter->element->add_inline_box(iter->box);
 519
 520                 ret_items.emplace_front(std::unique_ptr<line_box_item>(new lbi_continue(iter->element)));
 521         }
 522
 523         return std::move(ret_items);
 524 }
 525
 526 std::shared_ptr<litehtml::render_item> litehtml::line_box::get_first_text_part() const
 527 {
 528         for(const auto & item : m_items)
 529         {
 530                 if(item->get_type() == line_box_item::type_text_part)
 531                 {
 532                         return item->get_el();
 533                 }
 534         }
 535         return nullptr;
 536 }
 537
 538
 539 std::shared_ptr<litehtml::render_item> litehtml::line_box::get_last_text_part() const
 540 {
 541         for(auto iter = m_items.rbegin(); iter != m_items.rend(); iter++)
 542         {
 543                 if((*iter)->get_type() == line_box_item::type_text_part)
 544                 {
 545                         return (*iter)->get_el();
 546                 }
 547         }
 548         return nullptr;
 549 }
 550
 551
 552 bool litehtml::line_box::can_hold(const std::unique_ptr<line_box_item>& item, white_space ws) const
 553 {
 554     if(!item->get_el()->src_el()->is_inline()) return false;
 555
 556         if(item->get_type() == line_box_item::type_text_part)
 557         {
 558                 auto last_el = get_last_text_part();
 559
 560                 // force new line if the last placed element was line break
 561                 if (last_el && last_el->src_el()->is_break())
 562                 {
 563                         return false;
 564                 }
 565
 566                 // line break should stay in current line box
 567                 if (item->get_el()->src_el()->is_break())
 568                 {
 569                         return true;
 570                 }
 571
 572                 if (ws == white_space_nowrap || ws == white_space_pre ||
 573                         (ws == white_space_pre_wrap && item->get_el()->src_el()->is_space()))
 574                 {
 575                         return true;
 576                 }
 577
 578                 if (m_left + m_width + item->width() > m_right)
 579                 {
 580                         return false;
 581                 }
 582         }
 583
 584     return true;
 585 }
 586
 587 bool litehtml::line_box::have_last_space()  const
 588 {
 589         auto last_el = get_last_text_part();
 590         if(last_el)
 591         {
 592                 return last_el->src_el()->is_white_space() || last_el->src_el()->is_break();
 593         }
 594         return false;
 595 }
 596
 597 bool litehtml::line_box::is_empty() const
 598 {
 599     if(m_items.empty()) return true;
 600     for (const auto& el : m_items)
 601     {
 602                 if(el->get_type() == line_box_item::type_text_part)
 603                 {
 604                         if (!el->get_el()->skip() || el->get_el()->src_el()->is_break())
 605                         {
 606                                 return false;
 607                         }
 608                 }
 609     }
 610     return true;
 611 }
 612
 613 int litehtml::line_box::baseline() const
 614 {
 615     return m_baseline;
 616 }
 617
 618 int litehtml::line_box::top_margin() const
 619 {
 620     return 0;
 621 }
 622
 623 int litehtml::line_box::bottom_margin() const
 624 {
 625     return 0;
 626 }
 627
 628 void litehtml::line_box::y_shift( int shift )
 629 {
 630         m_top += shift;
 631     for (auto& el : m_items)
 632     {
 633         el->pos().y += shift;
 634     }
 635 }
 636
 637 bool litehtml::line_box::is_break_only() const
 638 {
 639     if(m_items.empty()) return false;
 640
 641         bool break_found = false;
 642
 643         for (auto iter = m_items.rbegin(); iter != m_items.rend(); iter++)
 644         {
 645                 if((*iter)->get_type() == line_box_item::type_text_part)
 646                 {
 647                         if((*iter)->get_el()->src_el()->is_break())
 648                         {
 649                                 break_found = true;
 650                         } else if(!(*iter)->get_el()->skip())
 651                         {
 652                                 return false;
 653                         }
 654                 }
 655         }
 656         return break_found;
 657 }
 658
 659 std::list< std::unique_ptr<litehtml::line_box_item> > litehtml::line_box::new_width( int left, int right)
 660 {
 661         std::list< std::unique_ptr<line_box_item> > ret_items;
 662     int add = left - m_left;
 663     if(add)
 664     {
 665                 m_left  = left;
 666                 m_right = right;
 667         m_width = 0;
 668         auto remove_begin = m_items.end();
 669                 auto i = m_items.begin();
 670                 i++;
 671                 while (i != m_items.end())
 672         {
 673             if(!(*i)->get_el()->skip())
 674             {
 675                 if(m_left + m_width + (*i)->width() > m_right)
 676                 {
 677                     remove_begin = i;
 678                     break;
 679                 } else
 680                 {
 681                                         (*i)->pos().x += add;
 682                     m_width += (*i)->get_el()->width();
 683                 }
 684             }
 685                         i++;
 686         }
 687         if(remove_begin != m_items.end())
 688         {
 689                         while(remove_begin != m_items.end())
 690                         {
 691                                 ret_items.emplace_back(std::move(*remove_begin));
 692                         }
 693             m_items.erase(remove_begin, m_items.end());
 694         }
 695     }
 696         return ret_items;
 697 }
 698