litehtml · tordex · Jun 12, 2023 · Jun 12, 2023
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -65,7 +65,6 @@ set(SOURCE_LITEHTML
     src/render_block_context.cpp
     src/render_block.cpp
     src/render_inline_context.cpp
-    src/render_inline.cpp
     src/render_table.cpp
     src/render_flex.cpp
     src/render_image.cpp
@@ -123,6 +122,13 @@ set(HEADER_LITEHTML
     include/litehtml/css_properties.h
     include/litehtml/line_box.h
     include/litehtml/render_item.h
+    include/litehtml/render_flex.h
+    include/litehtml/render_image.h
+    include/litehtml/render_inline.h
+    include/litehtml/render_table.h
+    include/litehtml/render_inline_context.h
+    include/litehtml/render_block_context.h
+    include/litehtml/render_block.h
     include/litehtml/master_css.h
     include/litehtml/string_id.h
     include/litehtml/formatting_context.h

diff --git a/include/litehtml/render_block.h b/include/litehtml/render_block.h
@@ -0,0 +1,40 @@
+#ifndef LITEHTML_RENDER_BLOCK_H
+#define LITEHTML_RENDER_BLOCK_H
+
+#include "render_item.h"
+
+namespace litehtml
+{
+	class render_item_block : public render_item
+	{
+	protected:
+		/**
+		 * Render block content.
+		 *
+		 * @param x - horizontal position of the content
+		 * @param y - vertical position of the content
+		 * @param second_pass - true is this is the second pass.
+		 * @param ret_width - input minimal width.
+		 * @param self_size - defines calculated size of block
+		 * @return return value is the minimal width of the content in block. Must be greater or equal to ret_width parameter
+		 */
+		virtual int _render_content(int x, int y, bool second_pass, const containing_block_context &self_size, formatting_context* fmt_ctx) {return 0;}
+		int _render(int x, int y, const containing_block_context &containing_block_size, formatting_context* fmt_ctx, bool second_pass) override;
+		int place_float(const std::shared_ptr<render_item> &el, int top, const containing_block_context &self_size, formatting_context* fmt_ctx);
+		virtual void fix_line_width(element_float flt,
+									const containing_block_context &containing_block_size, formatting_context* fmt_ctx)
+		{}
+
+	public:
+		explicit render_item_block(std::shared_ptr<element>  src_el) : render_item(std::move(src_el))
+		{}
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_block>(src_el());
+		}
+		std::shared_ptr<render_item> init() override;
+	};
+}
+
+#endif //LITEHTML_RENDER_BLOCK_H
diff --git a/include/litehtml/render_block_context.h b/include/litehtml/render_block_context.h
@@ -0,0 +1,29 @@
+#ifndef LITEHTML_RENDER_BLOCK_CONTEXT_H
+#define LITEHTML_RENDER_BLOCK_CONTEXT_H
+
+#include "render_block.h"
+
+namespace litehtml
+{
+	/**
+	 * In a block formatting context, boxes are laid out one after the other, vertically, beginning at the top of a
+	 * containing block.
+	 * https://www.w3.org/TR/CSS22/visuren.html#block-formatting
+	 */
+	class render_item_block_context : public render_item_block
+	{
+	protected:
+		int _render_content(int x, int y, bool second_pass, const containing_block_context &self_size, formatting_context* fmt_ctx) override;
+
+	public:
+		explicit render_item_block_context(std::shared_ptr<element>  src_el) : render_item_block(std::move(src_el))
+		{}
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_block_context>(src_el());
+		}
+	};
+}
+
+#endif //LITEHTML_RENDER_BLOCK_CONTEXT_H
diff --git a/include/litehtml/render_flex.h b/include/litehtml/render_flex.h
@@ -0,0 +1,46 @@
+#ifndef LITEHTML_RENDER_FLEX_H
+#define LITEHTML_RENDER_FLEX_H
+
+#include "render_block.h"
+
+namespace litehtml
+{
+	class render_item_flex : public render_item_block
+	{
+		struct flex_item
+		{
+			std::shared_ptr<render_item> el;
+			int base_size;
+			int main_size;
+			int min_width;
+			int max_width;
+			int line;
+
+			explicit flex_item(std::shared_ptr<render_item>  _el) :
+					el(std::move(_el)),
+					min_width(0),
+					max_width(0),
+					line(0),
+					base_size(0),
+					main_size(0)
+			{}
+		};
+	protected:
+		std::list<std::unique_ptr<flex_item>>   m_flex_items;
+
+		int _render_content(int x, int y, bool second_pass, const containing_block_context &self_size, formatting_context* fmt_ctx) override;
+
+	public:
+		explicit render_item_flex(std::shared_ptr<element>  src_el) : render_item_block(std::move(src_el))
+		{}
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_flex>(src_el());
+		}
+		void draw_children(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex) override;
+		std::shared_ptr<render_item> init() override;
+	};
+}
+
+#endif //LITEHTML_RENDER_FLEX_H
diff --git a/include/litehtml/render_image.h b/include/litehtml/render_image.h
@@ -0,0 +1,25 @@
+#ifndef LITEHTML_RENDER_IMAGE_H
+#define LITEHTML_RENDER_IMAGE_H
+
+#include "render_item.h"
+
+namespace litehtml
+{
+	class render_item_image : public render_item
+	{
+	protected:
+		int calc_max_height(int image_height, int containing_block_height);
+		int _render(int x, int y, const containing_block_context &containing_block_size, formatting_context* fmt_ctx, bool second_pass) override;
+
+	public:
+		explicit render_item_image(std::shared_ptr<element>  src_el) : render_item(std::move(src_el))
+		{}
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_image>(src_el());
+		}
+	};
+}
+
+#endif //LITEHTML_RENDER_IMAGE_H
diff --git a/include/litehtml/render_inline.h b/include/litehtml/render_inline.h
@@ -0,0 +1,30 @@
+#ifndef LITEHTML_RENDER_INLINE_H
+#define LITEHTML_RENDER_INLINE_H
+
+#include "render_item.h"
+
+namespace litehtml
+{
+	class render_item_inline : public render_item
+	{
+	protected:
+		position::vector m_boxes;
+
+	public:
+		explicit render_item_inline(std::shared_ptr<element>  src_el) : render_item(std::move(src_el))
+		{}
+
+		void get_inline_boxes( position::vector& boxes ) const override { boxes = m_boxes; }
+		void set_inline_boxes( position::vector& boxes ) override { m_boxes = boxes; }
+		void add_inline_box( const position& box ) override { m_boxes.emplace_back(box); };
+		void clear_inline_boxes() override { m_boxes.clear(); }
+		int get_base_line() override { return src_el()->css().get_font_metrics().base_line(); }
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_inline>(src_el());
+		}
+	};
+}
+
+#endif //LITEHTML_RENDER_INLINE_H
diff --git a/include/litehtml/render_inline_context.h b/include/litehtml/render_inline_context.h
@@ -0,0 +1,55 @@
+#ifndef LITEHTML_RENDER_INLINE_CONTEXT_H
+#define LITEHTML_RENDER_INLINE_CONTEXT_H
+
+#include "render_block.h"
+
+namespace litehtml
+{
+	/**
+	 * An inline formatting context is established by a block container box that contains no block-level boxes.
+	 * https://www.w3.org/TR/CSS22/visuren.html#inline-formatting
+	 */
+	class render_item_inline_context : public render_item_block
+	{
+		/**
+		 *	Structure contains elements with display: inline
+		 *	members:
+		 *	- element: 		render_item with display: inline
+		 *	- boxes: 		rectangles represented inline element content. There are can be many boxes if content
+		 *			 is split into some lines
+		 *	- start_box:	the start position of currently calculated box
+		 */
+		struct inlines_item
+		{
+			std::shared_ptr<render_item> element;
+			position::vector boxes;
+			position	start_box;
+
+			explicit inlines_item(const std::shared_ptr<render_item>& el) : element(el) {}
+		};
+	protected:
+		std::vector<std::unique_ptr<litehtml::line_box> > m_line_boxes;
+		int m_max_line_width;
+
+		int _render_content(int x, int y, bool second_pass, const containing_block_context &self_size, formatting_context* fmt_ctx) override;
+		void fix_line_width(element_float flt,
+							const containing_block_context &self_size, formatting_context* fmt_ctx) override;
+
+		std::list<std::unique_ptr<line_box_item> > finish_last_box(bool end_of_render, const containing_block_context &self_size);
+		void place_inline(std::unique_ptr<line_box_item> item, const containing_block_context &self_size, formatting_context* fmt_ctx);
+		int new_box(const std::unique_ptr<line_box_item>& el, line_context& line_ctx, const containing_block_context &self_size, formatting_context* fmt_ctx);
+		void apply_vertical_align() override;
+	public:
+		explicit render_item_inline_context(std::shared_ptr<element>  src_el) : render_item_block(std::move(src_el)), m_max_line_width(0)
+		{}
+
+		std::shared_ptr<render_item> clone() override
+		{
+			return std::make_shared<render_item_inline_context>(src_el());
+		}
+
+		int get_base_line() override;
+	};
+}
+
+#endif //LITEHTML_RENDER_INLINE_CONTEXT_H