text: /*
   * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice, this
   *    list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  #include <LibGUI/Painter.h>
  #include <LibWeb/DOM/Document.h>
  #include <LibWeb/DOM/HTMLBodyElement.h>
  #include <LibWeb/Frame/Frame.h>
  #include <LibWeb/Layout/LayoutBlock.h>
  #include <LibWeb/Layout/LayoutBox.h>
  
  //#define DRAW_BOXES_AROUND_LAYOUT_NODES
  //#define DRAW_BOXES_AROUND_HOVERED_NODES
  
  namespace Web {
  
  void LayoutBox::paint_border(RenderingContext& context, Edge edge, const Gfx::FloatRect& rect, CSS::PropertyID style_property_id, CSS::PropertyID color_property_id, CSS::PropertyID width_property_id)
  {
      auto border_width = style().property(width_property_id);
      if (!border_width.has_value())
          return;
  
      auto border_style = style().property(style_property_id);
      float width = border_width.value()->to_length().to_px(*this);
      if (width <= 0)
          return;
  
      int int_width = max((int)width, 1);
  
      Color color;
      auto border_color = style().property(color_property_id);
      if (border_color.has_value()) {
          color = border_color.value()->to_color(document());
      } else {
          // FIXME: This is basically CSS "currentColor" which should be handled elsewhere
          //        in a much more reusable way.
          auto current_color = style().property(CSS::PropertyID::Color);
          if (current_color.has_value())
              color = current_color.value()->to_color(document());
          else
              color = Color::Black;
      }
  
      auto first_point_for_edge = [](Edge edge, const Gfx::FloatRect& rect) {
          switch (edge) {
          case Edge::Top:
              return rect.top_left();
          case Edge::Right:
              return rect.top_right();
          case Edge::Bottom:
              return rect.bottom_left();
          case Edge::Left:
          default:
              return rect.top_left();
          }
      };
  
      auto second_point_for_edge = [](Edge edge, const Gfx::FloatRect& rect) {
          switch (edge) {
          case Edge::Top:
              return rect.top_right();
          case Edge::Right:
              return rect.bottom_right();
          case Edge::Bottom:
              return rect.bottom_right();
          case Edge::Left:
          default:
              return rect.bottom_left();
          }
      };
  
      auto p1 = first_point_for_edge(edge, rect);
      auto p2 = second_point_for_edge(edge, rect);
  
      if (border_style.has_value() && border_style.value()->to_string() == "inset") {
          auto top_left_color = Color::from_rgb(0x5a5a5a);
          auto bottom_right_color = Color::from_rgb(0x888888);
          color = (edge == Edge::Left || edge == Edge::Top) ? top_left_color : bottom_right_color;
      } else if (border_style.has_value() && border_style.value()->to_string() == "outset") {
          auto top_left_color = Color::from_rgb(0x888888);
          auto bottom_right_color = Color::from_rgb(0x5a5a5a);
          color = (edge == Edge::Left || edge == Edge::Top) ? top_left_color : bottom_right_color;
      }
  
      auto line_style = Gfx::Painter::LineStyle::Solid;
      if (border_style.has_value()) {
          if (border_style.value()->to_string() == "dotted")
              line_style = Gfx::Painter::LineStyle::Dotted;
          if (border_style.value()->to_string() == "dashed")
              line_style = Gfx::Painter::LineStyle::Dashed;
      }
  
      if (line_style != Gfx::Painter::LineStyle::Solid) {
          switch (edge) {
          case Edge::Top:
              p1.move_by(int_width / 2, int_width / 2);
              p2.move_by(-int_width / 2, int_width / 2);
              break;
          case Edge::Right:
              p1.move_by(-int_width / 2, int_width / 2);
              p2.move_by(-int_width / 2, -int_width / 2);
              break;
          case Edge::Bottom:
              p1.move_by(int_width / 2, -int_width / 2);
              p2.move_by(-int_width / 2, -int_width / 2);
              break;
          case Edge::Left:
              p1.move_by(int_width / 2, int_width / 2);
              p2.move_by(int_width / 2, -int_width / 2);
              break;
          }
          context.painter().draw_line({ (int)p1.x(), (int)p1.y() }, { (int)p2.x(), (int)p2.y() }, color, int_width, line_style);
          return;
      }
  
      auto draw_line = [&](auto& p1, auto& p2) {
          context.painter().draw_line({ (int)p1.x(), (int)p1.y() }, { (int)p2.x(), (int)p2.y() }, color, 1, line_style);
      };
  
      auto width_for = [&](CSS::PropertyID property_id) -> float {
          auto width = style().property(property_id);
          if (!width.has_value())
              return 0;
          return width.value()->to_length().to_px(*this);
      };
  
      float p1_step = 0;
      float p2_step = 0;
  
      switch (edge) {
      case Edge::Top:
          p1_step = width_for(CSS::PropertyID::BorderLeftWidth) / (float)int_width;
          p2_step = width_for(CSS::PropertyID::BorderRightWidth) / (float)int_width;
          for (int i = 0; i < int_width; ++i) {
              draw_line(p1, p2);
              p1.move_by(p1_step, 1);
              p2.move_by(-p2_step, 1);
          }
          break;
      case Edge::Right:
          p1_step = width_for(CSS::PropertyID::BorderTopWidth) / (float)int_width;
          p2_step = width_for(CSS::PropertyID::BorderBottomWidth) / (float)int_width;
          for (int i = int_width - 1; i >= 0; --i) {
              draw_line(p1, p2);
              p1.move_by(-1, p1_step);
              p2.move_by(-1, -p2_step);
          }
          break;
      case Edge::Bottom:
          p1_step = width_for(CSS::PropertyID::BorderLeftWidth) / (float)int_width;
          p2_step = width_for(CSS::PropertyID::BorderRightWidth) / (float)int_width;
          for (int i = int_width - 1; i >= 0; --i) {
              draw_line(p1, p2);
              p1.move_by(p1_step, -1);
              p2.move_by(-p2_step, -1);
          }
          break;
      case Edge::Left:
          p1_step = width_for(CSS::PropertyID::BorderTopWidth) / (float)int_width;
          p2_step = width_for(CSS::PropertyID::BorderBottomWidth) / (float)int_width;
          for (int i = 0; i < int_width; ++i) {
              draw_line(p1, p2);
              p1.move_by(1, p1_step);
              p2.move_by(1, -p2_step);
          }
          break;
      }
  }
  
  void LayoutBox::render(RenderingContext& context)
  {
      if (!is_visible())
          return;
  
      Gfx::PainterStateSaver saver(context.painter());
      if (is_fixed_position())
          context.painter().translate(context.scroll_offset());
  
  #ifdef DRAW_BOXES_AROUND_LAYOUT_NODES
      context.painter().draw_rect(m_rect, Color::Blue);
  #endif
  #ifdef DRAW_BOXES_AROUND_HOVERED_NODES
      if (!is_anonymous() && node() == document().hovered_node())
          context.painter().draw_rect(m_rect, Color::Red);
  #endif
  
      Gfx::FloatRect padded_rect;
      padded_rect.set_x(absolute_x() - box_model().padding().left.to_px(*this));
      padded_rect.set_width(width() + box_model().padding().left.to_px(*this) + box_model().padding().right.to_px(*this));
      padded_rect.set_y(absolute_y() - box_model().padding().top.to_px(*this));
      padded_rect.set_height(height() + box_model().padding().top.to_px(*this) + box_model().padding().bottom.to_px(*this));
  
      if (!is_body()) {
          auto bgcolor = style().property(CSS::PropertyID::BackgroundColor);
          if (bgcolor.has_value() && bgcolor.value()->is_color()) {
              context.painter().fill_rect(enclosing_int_rect(padded_rect), bgcolor.value()->to_color(document()));
          }
  
          auto bgimage = style().property(CSS::PropertyID::BackgroundImage);
          if (bgimage.has_value() && bgimage.value()->is_image()) {
              auto& image_value = static_cast<const ImageStyleValue&>(*bgimage.value());
              if (image_value.bitmap()) {
                  context.painter().draw_tiled_bitmap(enclosing_int_rect(padded_rect), *image_value.bitmap());
              }
          }
      }
  
      Gfx::FloatRect bordered_rect;
      bordered_rect.set_x(padded_rect.x() - box_model().border().left.to_px(*this));
      bordered_rect.set_width(padded_rect.width() + box_model().border().left.to_px(*this) + box_model().border().right.to_px(*this));
      bordered_rect.set_y(padded_rect.y() - box_model().border().top.to_px(*this));
      bordered_rect.set_height(padded_rect.height() + box_model().border().top.to_px(*this) + box_model().border().bottom.to_px(*this));
  
      paint_border(context, Edge::Left, bordered_rect, CSS::PropertyID::BorderLeftStyle, CSS::PropertyID::BorderLeftColor, CSS::PropertyID::BorderLeftWidth);
      paint_border(context, Edge::Right, bordered_rect, CSS::PropertyID::BorderRightStyle, CSS::PropertyID::BorderRightColor, CSS::PropertyID::BorderRightWidth);
      paint_border(context, Edge::Top, bordered_rect, CSS::PropertyID::BorderTopStyle, CSS::PropertyID::BorderTopColor, CSS::PropertyID::BorderTopWidth);
      paint_border(context, Edge::Bottom, bordered_rect, CSS::PropertyID::BorderBottomStyle, CSS::PropertyID::BorderBottomColor, CSS::PropertyID::BorderBottomWidth);
  
      LayoutNodeWithStyleAndBoxModelMetrics::render(context);
  
      if (node() && document().inspected_node() == node())
          context.painter().draw_rect(enclosing_int_rect(absolute_rect()), Color::Magenta);
  }
  
  HitTestResult LayoutBox::hit_test(const Gfx::IntPoint& position) const
  {
      // FIXME: It would be nice if we could confidently skip over hit testing
      //        parts of the layout tree, but currently we can't just check
      //        m_rect.contains() since inline text rects can't be trusted..
      HitTestResult result { absolute_rect().contains(position.x(), position.y()) ? this : nullptr };
      for_each_child([&](auto& child) {
          auto child_result = child.hit_test(position);
          if (child_result.layout_node)
              result = child_result;
      });
      return result;
  }
  
  void LayoutBox::set_needs_display()
  {
      if (!is_inline()) {
          frame().set_needs_display(enclosing_int_rect(absolute_rect()));
          return;
      }
  
      LayoutNode::set_needs_display();
  }
  
  bool LayoutBox::is_body() const
  {
      return node() && node() == document().body();
  }
  
  void LayoutBox::set_offset(const Gfx::FloatPoint& offset)
  {
      if (m_offset == offset)
          return;
      m_offset = offset;
      did_set_rect();
  }
  
  void LayoutBox::set_size(const Gfx::FloatSize& size)
  {
      if (m_size == size)
          return;
      m_size = size;
      did_set_rect();
  }
  
  Gfx::FloatPoint LayoutBox::effective_offset() const
  {
      if (m_containing_line_box_fragment)
          return m_containing_line_box_fragment->offset();
      return m_offset;
  }
  
  const Gfx::FloatRect LayoutBox::absolute_rect() const
  {
      Gfx::FloatRect rect { effective_offset(), size() };
      for (auto* block = containing_block(); block; block = block->containing_block()) {
          rect.move_by(block->effective_offset());
      }
      return rect;
  }
  
  void LayoutBox::set_containing_line_box_fragment(LineBoxFragment& fragment)
  {
      m_containing_line_box_fragment = fragment.make_weak_ptr();
  }
  
  StackingContext* LayoutBox::enclosing_stacking_context()
  {
      for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
          if (!ancestor->is_box())
              continue;
          auto& ancestor_box = to<LayoutBox>(*ancestor);
          if (!ancestor_box.establishes_stacking_context())
              continue;
          ASSERT(ancestor_box.stacking_context());
          return ancestor_box.stacking_context();
      }
      // We should always reach the LayoutDocument stacking context.
      ASSERT_NOT_REACHED();
  }
  
  bool LayoutBox::establishes_stacking_context() const
  {
      if (!has_style())
          return false;
      if (node() == document().root())
          return true;
      auto position = style().position();
      auto z_index = style().z_index();
      if (position == CSS::Position::Absolute || position == CSS::Position::Relative) {
          if (z_index.has_value())
              return true;
      }
      if (position == CSS::Position::Fixed || position == CSS::Position::Sticky)
          return true;
      return false;
  }
  
  }
  