Write layout logic at half way.

22 files changed, 711 insertions, 408 deletions

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 3f6f33c8..0c147ac6 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -72,6 +72,10 @@
     "string_span": "cpp",
     "numeric": "cpp",
     "pointers": "cpp",
-    "gsl_assert": "cpp"
+    "gsl_assert": "cpp",
+    "cstdarg": "cpp",
+    "locale": "cpp",
+    "xlocbuf": "cpp",
+    "xlocmes": "cpp"
   }
 }
diff --git a/include/cru/ui/render/BorderRenderObject.hpp b/include/cru/ui/render/BorderRenderObject.hpp
index b1fc4ba2..6c33473a 100644
--- a/include/cru/ui/render/BorderRenderObject.hpp
+++ b/include/cru/ui/render/BorderRenderObject.hpp
@@ -67,9 +67,11 @@ class BorderRenderObject : public RenderObject {
   RenderObject* HitTest(const Point& point) override;
 
  protected:
-  Size OnMeasureCore(const MeasureRequirement& requirement) override;
-  void OnLayoutCore(const Size& size) override;
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureCore(const MeasureRequirement& requirement,
+                     const MeasureSize& preferred_size) override;
+  void OnLayoutCore() override;
+  Size OnMeasureContent(const MeasureRequirement& requirement,
+                        const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
   void OnAfterLayout() override;
diff --git a/include/cru/ui/render/CanvasRenderObject.hpp b/include/cru/ui/render/CanvasRenderObject.hpp
index 402302cb..323b4800 100644
--- a/include/cru/ui/render/CanvasRenderObject.hpp
+++ b/include/cru/ui/render/CanvasRenderObject.hpp
@@ -2,9 +2,9 @@
 #include "RenderObject.hpp"
 
 namespace cru::ui::render {
-// The measure logic for `CanvasRenderObject` is that you set a desired size by
-// `SetDesiredSize` (not `SetPreferredSize`) and it will compare desired size
-// and available size and use the smaller one (by `Min`).
+// Layout logic:
+// If no preferred size is set. Then (100, 100) is used and then coerced to
+// required range.
 class CanvasRenderObject : public RenderObject {
  public:
   CanvasRenderObject();
@@ -21,14 +21,11 @@ class CanvasRenderObject : public RenderObject {
 
   Size GetDesiredSize() const { return desired_size_; }
 
-  // Set the desired size. This is the content size excluding padding and
-  // margin.
-  void SetDesiredSize(const Size& new_size) { desired_size_ = new_size; }
-
   IEvent<CanvasPaintEventArgs>* PaintEvent() { return &paint_event_; }
 
  protected:
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureContent(const MeasureRequirement& requirement,
+                        const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
  private:
diff --git a/include/cru/ui/render/FlexLayoutRenderObject.hpp b/include/cru/ui/render/FlexLayoutRenderObject.hpp
index 217ca6cb..f82bffad 100644
--- a/include/cru/ui/render/FlexLayoutRenderObject.hpp
+++ b/include/cru/ui/render/FlexLayoutRenderObject.hpp
@@ -31,7 +31,7 @@ class FlexLayoutRenderObject : public LayoutRenderObject<FlexChildLayoutData> {
   }
 
  protected:
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureContent(const MeasureRequirement& requirement, const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
  private:
diff --git a/include/cru/ui/render/LayoutUtility.hpp b/include/cru/ui/render/LayoutUtility.hpp
deleted file mode 100644
index 63d13fd3..00000000
--- a/include/cru/ui/render/LayoutUtility.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-#include "Base.hpp"
-
-namespace cru::ui::render {
-Size Min(const Size& left, const Size& right);
-Size Max(const Size& left, const Size& right);
-}  // namespace cru::ui::render
diff --git a/include/cru/ui/render/MeasureRequirement.hpp b/include/cru/ui/render/MeasureRequirement.hpp
index 661f40a9..5af5a057 100644
--- a/include/cru/ui/render/MeasureRequirement.hpp
+++ b/include/cru/ui/render/MeasureRequirement.hpp
@@ -1,23 +1,34 @@
 #pragma once
 #include "Base.hpp"
 
+#include <algorithm>
 #include <limits>
 
 namespace cru::ui::render {
-class MeasureLength {
+constexpr Size Min(const Size& left, const Size& right) {
+  return Size{std::min(left.width, right.width),
+              std::min(left.height, right.height)};
+}
+
+constexpr Size Max(const Size& left, const Size& right) {
+  return Size{std::max(left.width, right.width),
+              std::max(left.height, right.height)};
+}
+
+class MeasureLength final {
  public:
   struct tag_not_specify_t {};
   constexpr static tag_not_specify_t tag_not_specify{};
 
-  constexpr MeasureLength() : MeasureLength(0) {}
+  constexpr MeasureLength() : MeasureLength(tag_not_specify) {}
   constexpr MeasureLength(tag_not_specify_t) : length_(-1) {}
   constexpr MeasureLength(float length) : length_(length) {
     Expects(length >= 0);
   }
 
   MeasureLength(const MeasureLength& other) = default;
-  MeasureLength& operator=(const MeasureLength& other) = default;
-  MeasureLength& operator=(float length) {
+  constexpr MeasureLength& operator=(const MeasureLength& other) = default;
+  constexpr MeasureLength& operator=(float length) {
     Expects(length >= 0);
     length_ = length;
     return *this;
@@ -25,17 +36,44 @@ class MeasureLength {
 
   ~MeasureLength() = default;
 
-  constexpr static MeasureLength NotSpecify() {
+  constexpr static MeasureLength NotSpecified() {
     return MeasureLength{tag_not_specify};
   }
 
-  // What not specify means depends on situation.
-  // For max size, it means no limit.
-  constexpr bool IsNotSpecify() const { return length_ < 0; }
+  constexpr bool IsSpecified() const { return length_ >= 0.0f; }
+
+  // What not specified means depends on situation.
+  constexpr bool IsNotSpecified() const { return length_ < 0.0f; }
+
+  constexpr float GetLengthOr(float value) const {
+    return length_ < 0 ? value : length_;
+  }
 
   // If not specify max value of float is returned.
-  constexpr float GetLength() const {
-    return length_ < 0 ? std::numeric_limits<float>::max() : length_;
+  constexpr float GetLengthOrMax() const {
+    return GetLengthOr(std::numeric_limits<float>::max());
+  }
+
+  // If not specify 0 is returned.
+  constexpr float GetLengthOr0() const { return GetLengthOr(0.f); }
+
+  // If not specify, return value is undefined.
+  constexpr float GetLengthOrUndefined() const { return length_; }
+
+  // Not operator overload because this semantics is not very clear.
+  constexpr MeasureLength Plus(float length) const {
+    if (IsSpecified())
+      return length_ + length;
+    else
+      return NotSpecified();
+  }
+
+  // Not operator overload because this semantics is not very clear.
+  constexpr MeasureLength Minus(float length) const {
+    if (IsSpecified())
+      return std::max(length_ - length, 0.f);
+    else
+      return NotSpecified();
   }
 
   constexpr bool operator==(MeasureLength other) const {
@@ -46,38 +84,151 @@ class MeasureLength {
     return !operator==(other);
   }
 
+  constexpr static MeasureLength Min(MeasureLength left, MeasureLength right) {
+    if (left.IsNotSpecified()) {
+      if (right.IsNotSpecified())
+        return NotSpecified();
+      else
+        return right;
+    } else {
+      if (left.IsNotSpecified())
+        return left;
+      else
+        return std::min(left.length_, right.length_);
+    }
+  }
+
+  constexpr static MeasureLength Max(MeasureLength left, MeasureLength right) {
+    if (left.IsNotSpecified()) {
+      if (right.IsNotSpecified())
+        return NotSpecified();
+      else
+        return right;
+    } else {
+      if (left.IsNotSpecified())
+        return left;
+      else
+        return std::max(left.length_, right.length_);
+    }
+  }
+
  private:
-  // -1 for infinate
+  // -1 for not specify
   float length_;
 };
 
+struct MeasureSize {
+  MeasureLength width;
+  MeasureLength height;
+
+  constexpr MeasureSize() = default;
+  constexpr MeasureSize(MeasureLength width, MeasureLength height)
+      : width(width), height(height) {}
+  constexpr MeasureSize(const Size& size)
+      : width(size.width), height(size.height) {}
+  constexpr MeasureSize(const MeasureSize& other) = default;
+
+  MeasureSize& operator=(const MeasureSize& other) = default;
+  constexpr MeasureSize& operator=(const Size& other) {
+    width = other.width;
+    height = other.height;
+    return *this;
+  }
+
+  constexpr Size GetSizeOrMax() const {
+    return Size{width.GetLengthOrMax(), height.GetLengthOrMax()};
+  }
+
+  constexpr Size GetSizeOr0() const {
+    return Size{width.GetLengthOr0(), height.GetLengthOr0()};
+  }
+
+  constexpr MeasureSize Plus(const Size& size) const {
+    return MeasureSize{width.Plus(size.width), height.Plus(size.height)};
+  }
+
+  constexpr MeasureSize Minus(const Size& size) const {
+    return MeasureSize{width.Minus(size.width), height.Minus(size.height)};
+  }
+
+  constexpr MeasureSize OverrideBy(const MeasureSize& size) const {
+    return MeasureSize{
+        size.width.IsSpecified() ? size.width.GetLengthOrUndefined()
+                                 : this->width,
+        size.height.IsSpecified() ? size.height.GetLengthOrUndefined()
+                                  : this->height,
+    };
+  }
+
+  constexpr static MeasureSize NotSpecified() {
+    return MeasureSize{MeasureLength::NotSpecified(),
+                       MeasureLength::NotSpecified()};
+  }
+
+  constexpr static MeasureSize Min(const MeasureSize& left,
+                                   const MeasureSize& right) {
+    return MeasureSize{MeasureLength::Min(left.width, right.width),
+                       MeasureLength::Min(left.height, right.height)};
+  }
+
+  constexpr static MeasureSize Max(const MeasureSize& left,
+                                   const MeasureSize& right) {
+    return MeasureSize{MeasureLength::Max(left.width, right.width),
+                       MeasureLength::Max(left.height, right.height)};
+  }
+};
+
 struct MeasureRequirement {
-  MeasureLength max_width;
-  MeasureLength max_height;
+  MeasureSize max;
+  MeasureSize min;
 
   constexpr MeasureRequirement() = default;
-  constexpr MeasureRequirement(MeasureLength max_width,
-                               MeasureLength max_height)
-      : max_width(max_width), max_height(max_height) {}
-
-  constexpr MeasureRequirement(const Size& max_size)
-      : max_width(max_size.width), max_height(max_size.height) {}
+  constexpr MeasureRequirement(const MeasureSize& max, const MeasureSize& min)
+      : max(max), min(min) {}
 
   constexpr bool Satisfy(const Size& size) const {
-    if (!max_width.IsNotSpecify() && max_width.GetLength() < size.width)
-      return false;
-    if (!max_height.IsNotSpecify() && max_height.GetLength() < size.height)
-      return false;
-    return true;
+    return max.width.GetLengthOrMax() >= size.width &&
+           max.height.GetLengthOrMax() >= size.height &&
+           min.width.GetLengthOr0() <= size.width &&
+           min.height.GetLengthOr0() <= size.height;
+  }
+
+  constexpr MeasureRequirement Normalize() const {
+    MeasureRequirement result = *this;
+    if (result.min.width.GetLengthOr0() > result.max.width.GetLengthOrMax())
+      result.min.width = result.max.width;
+
+    if (result.min.height.GetLengthOr0() > result.max.height.GetLengthOrMax())
+      result.min.height = result.max.height;
+    return result;
+  }
+
+  constexpr Size Coerce(const Size& size) const {
+    // This order guarentees result is the same as normalized.
+    return Min(Max(size, min.GetSizeOr0()), max.GetSizeOrMax());
   }
 
-  constexpr Size GetMaxSize() const {
-    return Size{max_width.GetLength(), max_height.GetLength()};
+  constexpr MeasureSize Coerce(const MeasureSize& size) const {
+    MeasureSize result = size;
+    if (result.width.IsSpecified())
+      // This order guarentees result is the same as normalized.
+      result.width = std::min(std::max(min.width.GetLengthOr0(),
+                                       result.width.GetLengthOrUndefined()),
+                              max.width.GetLengthOrMax());
+
+    if (result.height.IsSpecified())
+      // This order guarentees result is the same as normalized.
+      result.height = std::min(std::max(min.height.GetLengthOr0(),
+                                        result.height.GetLengthOrUndefined()),
+                               max.height.GetLengthOrMax());
+
+    return result;
   }
 
-  constexpr static MeasureRequirement Infinate() {
-    return MeasureRequirement{MeasureLength::NotSpecify(),
-                              MeasureLength::NotSpecify()};
+  constexpr static MeasureRequirement Merge(const MeasureRequirement& left,
+                                            const MeasureRequirement& right) {
+    return MeasureRequirement{MeasureSize::Min(left.max, right.max),
+                              MeasureSize::Max(left.min, right.min)};
   }
 };
 }  // namespace cru::ui::render
diff --git a/include/cru/ui/render/RenderObject.hpp b/include/cru/ui/render/RenderObject.hpp
index 72716d2e..823eabd6 100644
--- a/include/cru/ui/render/RenderObject.hpp
+++ b/include/cru/ui/render/RenderObject.hpp
@@ -10,6 +10,23 @@ namespace cru::ui::render {
 // manage lifecycle of its render objects. Since control will destroy its
 // children when destroyed, render objects will be destroyed along with it.
 //
+// About layout:
+// Render object should be able to deal with arbitrary size as the result of
+// measure and layout.
+//
+// Parent may pass calculated preferred size down. But the preferred size set on
+// child itself takes precedence.
+//
+// Each render object should obey the measure requirement to set size and report
+// a warning when that requirement can't be satisfied with probably bigger size
+// of children than that of itself and optional visual effect to indicate that.
+//
+// If size of chilren are less than min size requirement, then render object
+// should try to fill the rest area. If size of children are more than max size
+// requirement, then render object should display a warning of the layout
+// problem and use the max size of itself with children exceeding its bound.
+// (Or better you could use some visual effect to indicate that.)
+//
 // To write a custom RenderObject, override following methods:
 // public:
 //  void Draw(platform::graph::IPainter* painter) override;
@@ -59,16 +76,46 @@ class RenderObject : public Object {
   Point FromRootToContent(const Point& point) const;
 
   Thickness GetMargin() const { return margin_; }
-  void SetMargin(const Thickness& margin) { margin_ = margin; }
+  void SetMargin(const Thickness& margin) {
+    margin_ = margin;
+    InvalidateLayout();
+  }
 
   Thickness GetPadding() const { return padding_; }
-  void SetPadding(const Thickness& padding) { padding_ = padding; }
+  void SetPadding(const Thickness& padding) {
+    padding_ = padding;
+    InvalidateLayout();
+  }
+
+  MeasureSize GetPreferredSize() const { return preferred_size_; }
+  void SetPreferredSize(const MeasureSize& preferred_size) {
+    preferred_size_ = preferred_size;
+    InvalidateLayout();
+  }
+
+  MeasureSize GetMinSize() const { return custom_measure_requirement_.min; }
+  void SetMinSize(const MeasureSize& min_size) {
+    custom_measure_requirement_.min = min_size;
+    InvalidateLayout();
+  }
 
-  Size GetMeasuredSize() const { return measured_size_; }
+  MeasureSize GetMaxSize() const { return custom_measure_requirement_.max; }
+  void SetMaxSize(const MeasureSize& max_size) {
+    custom_measure_requirement_.max = max_size;
+    InvalidateLayout();
+  }
 
-  void Measure(const MeasureRequirement& requirement);
-  // Size of rect must not be negative.
-  void Layout(const Rect& rect);
+  MeasureRequirement GetCustomMeasureRequirement() const {
+    return custom_measure_requirement_;
+  }
+
+  // This will call OnMeasureCore and set the size of this render object.
+  // This can be called multiple times on children during measure to adjust for
+  // better size.
+  void Measure(const MeasureRequirement& requirement,
+               const MeasureSize& preferred_size);
+  // This will set offset of this render object and call OnLayoutCore.
+  void Layout(const Point& offset);
 
   virtual void Draw(platform::graph::IPainter* painter) = 0;
 
@@ -95,21 +142,25 @@ class RenderObject : public Object {
   virtual void OnRemoveChild(RenderObject* removed_child, Index position);
 
   // Size measure including margin and padding. Please reduce margin and padding
-  // or other custom things and pass the result content measure requirement to
-  // OnMeasureContent.
-  // Return value must not be negative and not bigger than requirement.
-  virtual Size OnMeasureCore(const MeasureRequirement& requirement);
-
-  // Size including margin and padding. Please reduce margin and padding or
-  // other custom things and pass the result content rect to OnLayoutContent.
-  // Parameter size are never negative.
-  virtual void OnLayoutCore(const Size& size);
-
-  // Do not consider margin or padding in this method because they are already
-  // considered in OnMeasureCore. Returned size should never be bigger than
-  // requirement.
-  virtual Size OnMeasureContent(const MeasureRequirement& requirement) = 0;
-
+  // or other custom things and pass the result content measure requirement and
+  // preferred size to OnMeasureContent. Return value must not be negative and
+  // must obey requirement. Preferred size may not be in range so need to be
+  // coerced.
+  virtual Size OnMeasureCore(const MeasureRequirement& requirement,
+                             const MeasureSize& preferred_size);
+
+  // Please reduce margin and padding or other custom things and pass the result
+  // content rect to OnLayoutContent.
+  virtual void OnLayoutCore();
+
+  // Override this function to measure content and children(Call Measure on
+  // them). Do not consider margin or padding in this method because they are
+  // already considered in OnMeasureCore. Returned size must obey requirement.
+  // Caller should guarantee preferred_size is corerced into required range.
+  virtual Size OnMeasureContent(const MeasureRequirement& requirement,
+                                const MeasureSize& preferred_size) = 0;
+
+  // Layout all content and children(Call Layout on them).
   // Lefttop of content_rect should be added when calculated children's offset.
   virtual void OnLayoutContent(const Rect& content_rect) = 0;
 
@@ -136,9 +187,10 @@ class RenderObject : public Object {
   Point offset_{};
   Size size_{};
 
+  MeasureSize preferred_size_;
+  MeasureRequirement custom_measure_requirement_;
+
   Thickness margin_{};
   Thickness padding_{};
-
-  Size measured_size_{};
 };
 }  // namespace cru::ui::render
diff --git a/include/cru/ui/render/ScrollRenderObject.hpp b/include/cru/ui/render/ScrollRenderObject.hpp
index 774501a1..9799c0d9 100644
--- a/include/cru/ui/render/ScrollRenderObject.hpp
+++ b/include/cru/ui/render/ScrollRenderObject.hpp
@@ -27,7 +27,7 @@ class ScrollRenderObject : public RenderObject {
   // If available size is bigger than child's preferred size, then child's
   // preferred size is taken.
   // If not, all available size is taken while forming a scroll area.
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureContent(const MeasureRequirement& requirement, const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
  private:
diff --git a/include/cru/ui/render/StackLayoutRenderObject.hpp b/include/cru/ui/render/StackLayoutRenderObject.hpp
index 2320e1ca..902c9d5c 100644
--- a/include/cru/ui/render/StackLayoutRenderObject.hpp
+++ b/include/cru/ui/render/StackLayoutRenderObject.hpp
@@ -11,7 +11,7 @@ class StackLayoutRenderObject
   ~StackLayoutRenderObject() = default;
 
  protected:
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureContent(const MeasureRequirement& requirement, const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 };
 }  // namespace cru::ui::render
diff --git a/include/cru/ui/render/TextRenderObject.hpp b/include/cru/ui/render/TextRenderObject.hpp
index 96bb5997..efa8c2b8 100644
--- a/include/cru/ui/render/TextRenderObject.hpp
+++ b/include/cru/ui/render/TextRenderObject.hpp
@@ -4,6 +4,19 @@
 #include <string>
 
 namespace cru::ui::render {
+// Layout logic:
+// 1. If preferred width is set then it is taken to do a text measure. If not
+// set, then max width is taken to do that.
+// 2. If the actual width of text after measure exceeds the required width,
+// coerced value is returned and an error is reported. If preferred width is set
+// and actual width is smaller than that, then preferred width is used. If
+// preferred width is not set, then the same thing is applied to min width.
+// 3. If actual height of text is bigger than max height, an error is reported
+// and coerced value is returned. Or height is lifted up to be at least
+// preferred size if set or min height.
+//
+// If the result layout box is bigger than actual text box, then text is center
+// aligned.
 class TextRenderObject : public RenderObject {
  public:
   constexpr static float default_caret_width = 2;
@@ -64,7 +77,9 @@ class TextRenderObject : public RenderObject {
   RenderObject* HitTest(const Point& point) override;
 
  protected:
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  // See remarks of this class.
+  Size OnMeasureContent(const MeasureRequirement& requirement,
+                        const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
   void OnAfterLayout() override;
diff --git a/include/cru/ui/render/WindowRenderObject.hpp b/include/cru/ui/render/WindowRenderObject.hpp
index d993dc58..d64a216d 100644
--- a/include/cru/ui/render/WindowRenderObject.hpp
+++ b/include/cru/ui/render/WindowRenderObject.hpp
@@ -16,7 +16,8 @@ class WindowRenderObject : public RenderObject {
   RenderObject* HitTest(const Point& point) override;
 
  protected:
-  Size OnMeasureContent(const MeasureRequirement& requirement) override;
+  Size OnMeasureContent(const MeasureRequirement& requirement,
+                        const MeasureSize& preferred_size) override;
   void OnLayoutContent(const Rect& content_rect) override;
 
  private:
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index 68efa903..9043974e 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -23,7 +23,6 @@ add_library(cru_ui STATIC
 	render/BorderRenderObject.cpp
 	render/CanvasRenderObject.cpp
 	render/FlexLayoutRenderObject.cpp
-	render/LayoutUtility.cpp
 	render/RenderObject.cpp
 	render/ScrollRenderObject.cpp
 	render/StackLayoutRenderObject.cpp
@@ -53,7 +52,6 @@ target_sources(cru_ui PUBLIC
 	${CRU_UI_INCLUDE_DIR}/render/CanvasRenderObject.hpp
 	${CRU_UI_INCLUDE_DIR}/render/FlexLayoutRenderObject.hpp
 	${CRU_UI_INCLUDE_DIR}/render/LayoutRenderObject.hpp
-	${CRU_UI_INCLUDE_DIR}/render/LayoutUtility.hpp
 	${CRU_UI_INCLUDE_DIR}/render/MeasureRequirement.hpp
 	${CRU_UI_INCLUDE_DIR}/render/RenderObject.hpp
 	${CRU_UI_INCLUDE_DIR}/render/ScrollRenderObject.hpp
diff --git a/src/ui/UiHost.cpp b/src/ui/UiHost.cpp
index 7047d43f..09f8fd9b 100644
--- a/src/ui/UiHost.cpp
+++ b/src/ui/UiHost.cpp
@@ -166,8 +166,11 @@ void UiHost::Relayout() {
   const auto client_size = native_window
                                ? native_window->GetClientSize()
                                : Size{100, 100};  // a reasonable assumed size
-  root_render_object_->Measure(client_size);
-  root_render_object_->Layout(Rect{Point{}, client_size});
+  root_render_object_->Measure(
+      render::MeasureRequirement{client_size,
+                                 render::MeasureSize::NotSpecified()},
+      render::MeasureSize::NotSpecified());
+  root_render_object_->Layout(Point{});
 }
 
 bool UiHost::RequestFocusFor(Control* control) {
diff --git a/src/ui/render/BorderRenderObject.cpp b/src/ui/render/BorderRenderObject.cpp
index ad0c6455..74e50561 100644
--- a/src/ui/render/BorderRenderObject.cpp
+++ b/src/ui/render/BorderRenderObject.cpp
@@ -73,9 +73,10 @@ RenderObject* BorderRenderObject::HitTest(const Point& point) {
   }
 }
 
-Size BorderRenderObject::OnMeasureCore(const MeasureRequirement& requirement) {
+Size BorderRenderObject::OnMeasureCore(const MeasureRequirement& requirement,
+                                       const MeasureSize& preferred_size) {
   if (!is_border_enabled_) {
-    return RenderObject::OnMeasureCore(requirement);
+    return RenderObject::OnMeasureCore(requirement, preferred_size);
   }
 
   const auto margin = GetMargin();
@@ -90,36 +91,51 @@ Size BorderRenderObject::OnMeasureCore(const MeasureRequirement& requirement) {
 
   MeasureRequirement content_requirement = requirement;
 
-  if (!requirement.max_width.IsNotSpecify()) {
-    const auto max_width = requirement.max_width.GetLength();
+  if (!requirement.max.width.IsNotSpecified()) {
+    const auto max_width = requirement.max.width.GetLengthOrMax();
     if (coerced_space_size.width > max_width) {
       log::Warn(
-          "Measure: horizontal length of padding and margin is bigger than "
-          "available length.");
+          "BorderRenderObject: During measure, horizontal length of padding, "
+          "border and margin is bigger than required max length.");
       coerced_space_size.width = max_width;
     }
-    content_requirement.max_width = max_width - coerced_space_size.width;
+    content_requirement.max.width = max_width - coerced_space_size.width;
   }
 
-  if (!requirement.max_height.IsNotSpecify()) {
-    const auto max_height = requirement.max_height.GetLength();
+  if (!requirement.min.width.IsNotSpecified()) {
+    const auto min_width = requirement.min.width.GetLengthOr0();
+    content_requirement.min.width = std::max(0.f, min_width - space_size.width);
+  }
+
+  if (!requirement.max.height.IsNotSpecified()) {
+    const auto max_height = requirement.max.height.GetLengthOrMax();
     if (coerced_space_size.height > max_height) {
       log::Warn(
-          "Measure: horizontal length of padding and margin is bigger than "
-          "available length.");
+          "BorderRenderObject: During measure, vertical length of padding, "
+          "border and margin is bigger than required max length.");
       coerced_space_size.height = max_height;
     }
-    content_requirement.max_height = max_height - coerced_space_size.height;
+    content_requirement.max.height = max_height - coerced_space_size.height;
   }
 
-  const auto content_size = OnMeasureContent(content_requirement);
+  if (!requirement.min.height.IsNotSpecified()) {
+    const auto min_height = requirement.min.height.GetLengthOr0();
+    content_requirement.min.height =
+        std::max(0.f, min_height - space_size.height);
+  }
+
+  MeasureSize content_preferred_size =
+      content_requirement.Coerce(preferred_size.Minus(space_size));
+
+  const auto content_size =
+      OnMeasureContent(content_requirement, content_preferred_size);
 
   return coerced_space_size + content_size;
-}  // namespace cru::ui::render
+}
 
-void BorderRenderObject::OnLayoutCore(const Size& size) {
+void BorderRenderObject::OnLayoutCore() {
   if (!is_border_enabled_) {
-    return RenderObject::OnLayoutCore(size);
+    return RenderObject::OnLayoutCore();
   }
 
   const auto margin = GetMargin();
@@ -129,18 +145,20 @@ void BorderRenderObject::OnLayoutCore(const Size& size) {
                   margin.GetVerticalTotal() + padding.GetVerticalTotal() +
                       border_thickness_.GetVerticalTotal()};
 
+  const auto size = GetSize();
+
   auto content_size = size - space_size;
 
   if (content_size.width < 0) {
     log::Warn(
-        "Layout: horizontal length of padding, border and margin is bigger "
-        "than available length.");
+        "BorderRenderObject: During layout, horizontal length of padding, "
+        "border and margin is bigger than available length.");
     content_size.width = 0;
   }
   if (content_size.height < 0) {
     log::Warn(
-        "Layout: vertical length of padding, border and margin is bigger "
-        "than available length.");
+        "BorderRenderObject: During layout, vertical length of padding, "
+        "border and margin is bigger than available length.");
     content_size.height = 0;
   }
 
@@ -158,12 +176,12 @@ void BorderRenderObject::OnLayoutCore(const Size& size) {
   OnLayoutContent(content_rect);
 }
 
-Size BorderRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
+Size BorderRenderObject::OnMeasureContent(const MeasureRequirement& requirement,
+                                          const MeasureSize& preferred_size) {
   const auto child = GetSingleChild();
   if (child) {
-    child->Measure(requirement);
-    return child->GetMeasuredSize();
+    child->Measure(requirement, preferred_size);
+    return child->GetSize();
   } else {
     return Size{};
   }
@@ -172,7 +190,7 @@ Size BorderRenderObject::OnMeasureContent(
 void BorderRenderObject::OnLayoutContent(const Rect& content_rect) {
   const auto child = GetSingleChild();
   if (child) {
-    child->Layout(content_rect);
+    child->Layout(content_rect.GetLeftTop());
   }
 }
 
diff --git a/src/ui/render/CanvasRenderObject.cpp b/src/ui/render/CanvasRenderObject.cpp
index 72eb3570..211d1fce 100644
--- a/src/ui/render/CanvasRenderObject.cpp
+++ b/src/ui/render/CanvasRenderObject.cpp
@@ -1,7 +1,5 @@
 #include "cru/ui/render/CanvasRenderObject.hpp"
 
-#include "cru/ui/render/LayoutUtility.hpp"
-
 namespace cru::ui::render {
 CanvasRenderObject::CanvasRenderObject() : RenderObject(ChildMode::None) {}
 
@@ -18,9 +16,10 @@ RenderObject* CanvasRenderObject::HitTest(const Point& point) {
   return padding_rect.IsPointInside(point) ? this : nullptr;
 }
 
-Size CanvasRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
-  return Min(requirement.GetMaxSize(), GetDesiredSize());
+Size CanvasRenderObject::OnMeasureContent(const MeasureRequirement& requirement,
+                                          const MeasureSize& preferred_size) {
+  return requirement.Coerce(Size{preferred_size.width.GetLengthOr(100),
+                                 preferred_size.height.GetLengthOr(100)});
 }
 
 void CanvasRenderObject::OnLayoutContent(const Rect& content_rect) {
diff --git a/src/ui/render/FlexLayoutRenderObject.cpp b/src/ui/render/FlexLayoutRenderObject.cpp
index 72341a64..fcaf6f9a 100644
--- a/src/ui/render/FlexLayoutRenderObject.cpp
+++ b/src/ui/render/FlexLayoutRenderObject.cpp
@@ -7,194 +7,207 @@
 
 namespace cru::ui::render {
 Size FlexLayoutRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
-  const bool horizontal = (direction_ == FlexDirection::Horizontal ||
-                           direction_ == FlexDirection::HorizontalReverse);
-
-  const auto main_max_length =
-      horizontal ? requirement.max_width : requirement.max_height;
-  const auto cross_max_length =
-      horizontal ? requirement.max_height : requirement.max_width;
-
-  std::function<float(const Size&)> get_main_length;
-  std::function<float(const Size&)> get_cross_length;
-  std::function<void(Size&, const Size&)> calculate_result_size;
-  std::function<MeasureRequirement(MeasureLength main, MeasureLength cross)>
-      create_requirement;
-
-  if (horizontal) {
-    get_main_length = [](const Size& size) { return size.width; };
-    get_cross_length = [](const Size& size) { return size.height; };
-    calculate_result_size = [](Size& result, const Size& child_size) {
-      result.width += child_size.width;
-      result.height = std::max(result.height, child_size.height);
-    };
-    create_requirement = [](MeasureLength main, MeasureLength cross) {
-      return MeasureRequirement{main, cross};
-    };
-  } else {
-    get_main_length = [](const Size& size) { return size.height; };
-    get_cross_length = [](const Size& size) { return size.width; };
-    calculate_result_size = [](Size& result, const Size& child_size) {
-      result.height += child_size.height;
-      result.width = std::max(result.width, child_size.width);
-    };
-    create_requirement = [](MeasureLength main, MeasureLength cross) {
-      return MeasureRequirement{cross, main};
-    };
-  }
-
-  const auto& children = GetChildren();
-  Index children_count = children.size();
-
-  if (!main_max_length.IsNotSpecify()) {
-    float remain_main_length = main_max_length.GetLength();
-
-    for (Index i = 0; i < children_count; i++) {
-      const auto child = children[i];
-      child->Measure(create_requirement(remain_main_length, cross_max_length));
-      const auto measure_result = child->GetMeasuredSize();
-      remain_main_length -= get_main_length(measure_result);
-    }
-
-    if (remain_main_length > 0) {
-      std::vector<Index> expand_children;
-      float total_expand_factor = 0;
-
-      for (Index i = 0; i < children_count; i++) {
-        const auto factor = GetChildLayoutData(i)->expand_factor;
-        if (factor > 0) {
-          expand_children.push_back(i);
-          total_expand_factor += factor;
-        }
-      }
-
-      for (const Index i : expand_children) {
-        const float distributed_grow_length =
-            remain_main_length *
-            (GetChildLayoutData(i)->expand_factor / total_expand_factor);
-        const auto child = children[i];
-        const float new_main_length =
-            get_main_length(child->GetMeasuredSize()) + distributed_grow_length;
-        child->Measure(create_requirement(new_main_length, cross_max_length));
-      }
-    } else if (remain_main_length < 0) {
-      std::vector<Index> shrink_children;
-      float total_shrink_factor = 0;
-
-      for (Index i = 0; i < children_count; i++) {
-        const auto factor = GetChildLayoutData(i)->shrink_factor;
-        if (factor > 0) {
-          shrink_children.push_back(i);
-          total_shrink_factor += factor;
-        }
-      }
-
-      for (const Index i : shrink_children) {
-        const float distributed_shrink_length =  // negative
-            remain_main_length *
-            (GetChildLayoutData(i)->shrink_factor / total_shrink_factor);
-        const auto child = children[i];
-        float new_main_length = get_main_length(child->GetMeasuredSize()) +
-                                distributed_shrink_length;
-        new_main_length = new_main_length > 0 ? new_main_length : 0;
-        child->Measure(create_requirement(new_main_length, cross_max_length));
-      }
-    }
-  } else {
-    for (Index i = 0; i < children_count; i++) {
-      const auto child = children[i];
-      child->Measure(requirement);
-    }
-  }
-
-  Size result;
-  for (auto child : children) {
-    calculate_result_size(result, child->GetMeasuredSize());
-  }
-
-  return result;
+    const MeasureRequirement& requirement, const MeasureSize& preferred_size) {
+  // TODO: Rewrite this.
+  CRU_UNUSED(requirement);
+  CRU_UNUSED(preferred_size);
+  throw std::runtime_error("Not implemented.");
+
+  // const bool horizontal = (direction_ == FlexDirection::Horizontal ||
+  //                          direction_ == FlexDirection::HorizontalReverse);
+
+  // const auto main_max_length =
+  //     horizontal ? requirement.max_width : requirement.max_height;
+  // const auto cross_max_length =
+  //     horizontal ? requirement.max_height : requirement.max_width;
+
+  // std::function<float(const Size&)> get_main_length;
+  // std::function<float(const Size&)> get_cross_length;
+  // std::function<void(Size&, const Size&)> calculate_result_size;
+  // std::function<MeasureRequirement(MeasureLength main, MeasureLength cross)>
+  //     create_requirement;
+
+  // if (horizontal) {
+  //   get_main_length = [](const Size& size) { return size.width; };
+  //   get_cross_length = [](const Size& size) { return size.height; };
+  //   calculate_result_size = [](Size& result, const Size& child_size) {
+  //     result.width += child_size.width;
+  //     result.height = std::max(result.height, child_size.height);
+  //   };
+  //   create_requirement = [](MeasureLength main, MeasureLength cross) {
+  //     return MeasureRequirement{main, cross};
+  //   };
+  // } else {
+  //   get_main_length = [](const Size& size) { return size.height; };
+  //   get_cross_length = [](const Size& size) { return size.width; };
+  //   calculate_result_size = [](Size& result, const Size& child_size) {
+  //     result.height += child_size.height;
+  //     result.width = std::max(result.width, child_size.width);
+  //   };
+  //   create_requirement = [](MeasureLength main, MeasureLength cross) {
+  //     return MeasureRequirement{cross, main};
+  //   };
+  // }
+
+  // const auto& children = GetChildren();
+  // Index children_count = children.size();
+
+  // if (!main_max_length.IsNotSpecify()) {
+  //   float remain_main_length = main_max_length.GetLengthOrMax();
+
+  //   for (Index i = 0; i < children_count; i++) {
+  //     const auto child = children[i];
+  //     child->Measure(create_requirement(remain_main_length,
+  //     cross_max_length)); const auto measure_result =
+  //     child->GetMeasuredSize(); remain_main_length -=
+  //     get_main_length(measure_result);
+  //   }
+
+  //   if (remain_main_length > 0) {
+  //     std::vector<Index> expand_children;
+  //     float total_expand_factor = 0;
+
+  //     for (Index i = 0; i < children_count; i++) {
+  //       const auto factor = GetChildLayoutData(i)->expand_factor;
+  //       if (factor > 0) {
+  //         expand_children.push_back(i);
+  //         total_expand_factor += factor;
+  //       }
+  //     }
+
+  //     for (const Index i : expand_children) {
+  //       const float distributed_grow_length =
+  //           remain_main_length *
+  //           (GetChildLayoutData(i)->expand_factor / total_expand_factor);
+  //       const auto child = children[i];
+  //       const float new_main_length =
+  //           get_main_length(child->GetMeasuredSize()) +
+  //           distributed_grow_length;
+  //       child->Measure(create_requirement(new_main_length,
+  //       cross_max_length));
+  //     }
+  //   } else if (remain_main_length < 0) {
+  //     std::vector<Index> shrink_children;
+  //     float total_shrink_factor = 0;
+
+  //     for (Index i = 0; i < children_count; i++) {
+  //       const auto factor = GetChildLayoutData(i)->shrink_factor;
+  //       if (factor > 0) {
+  //         shrink_children.push_back(i);
+  //         total_shrink_factor += factor;
+  //       }
+  //     }
+
+  //     for (const Index i : shrink_children) {
+  //       const float distributed_shrink_length =  // negative
+  //           remain_main_length *
+  //           (GetChildLayoutData(i)->shrink_factor / total_shrink_factor);
+  //       const auto child = children[i];
+  //       float new_main_length = get_main_length(child->GetMeasuredSize()) +
+  //                               distributed_shrink_length;
+  //       new_main_length = new_main_length > 0 ? new_main_length : 0;
+  //       child->Measure(create_requirement(new_main_length,
+  //       cross_max_length));
+  //     }
+  //   }
+  // } else {
+  //   for (Index i = 0; i < children_count; i++) {
+  //     const auto child = children[i];
+  //     child->Measure(requirement);
+  //   }
+  // }
+
+  // Size result;
+  // for (auto child : children) {
+  //   calculate_result_size(result, child->GetMeasuredSize());
+  // }
+
+  // return result;
 }
 
 void FlexLayoutRenderObject::OnLayoutContent(const Rect& content_rect) {
-  auto calculate_anchor = [](int alignment, float start_point,
-                             float total_length,
-                             float content_length) -> float {
-    switch (alignment) {
-      case internal::align_start:
-        return start_point;
-      case internal::align_center:
-        return start_point + (total_length - content_length) / 2.0f;
-      case internal::align_end:
-        return start_point + total_length - content_length;
-      default:
-        return start_point;
-    }
-  };
-
-  const auto& children = GetChildren();
-  if (direction_ == FlexDirection::Horizontal ||
-      direction_ == FlexDirection::HorizontalReverse) {
-    float actual_content_width = 0;
-    for (const auto child : children) {
-      actual_content_width += child->GetMeasuredSize().width;
-    }
-
-    const float content_anchor_x =
-        calculate_anchor(static_cast<int>(content_main_align_), 0,
-                         content_rect.width, actual_content_width);
-
-    float anchor_x = 0;
-    for (int i = 0; i < static_cast<int>(children.size()); i++) {
-      const auto child = children[i];
-      const auto size = child->GetMeasuredSize();
-
-      float real_anchor_x = anchor_x + content_anchor_x;
-      if (direction_ == FlexDirection::Horizontal)
-        real_anchor_x = content_rect.left + real_anchor_x;
-      else
-        real_anchor_x = content_rect.GetRight() - real_anchor_x;
-      child->Layout(Rect{
-          real_anchor_x,
-          calculate_anchor(
-              static_cast<int>(GetChildLayoutData(i)->cross_alignment.value_or(
-                  this->item_cross_align_)),
-              content_rect.top, content_rect.height, size.height),
-          size.width, size.height});
-
-      anchor_x += size.width;
-    }
-  } else {
-    float actual_content_height = 0;
-    for (const auto child : children) {
-      actual_content_height = child->GetMeasuredSize().height;
-    }
-
-    const float content_anchor_y =
-        calculate_anchor(static_cast<int>(content_main_align_), 0,
-                         content_rect.height, actual_content_height);
-
-    float anchor_y = 0;
-    for (int i = 0; i < static_cast<int>(children.size()); i++) {
-      const auto child = children[i];
-      const auto size = child->GetMeasuredSize();
-
-      float real_anchor_y = anchor_y + content_anchor_y;
-      if (direction_ == FlexDirection::Vertical) {
-        real_anchor_y = content_rect.top + real_anchor_y;
-      } else {
-        real_anchor_y = content_rect.GetBottom() - real_anchor_y;
-      }
-      child->Layout(Rect{
-          real_anchor_y,
-          calculate_anchor(
-              static_cast<int>(GetChildLayoutData(i)->cross_alignment.value_or(
-                  this->item_cross_align_)),
-              content_rect.left, content_rect.width, size.width),
-          size.width, size.height});
-
-      anchor_y += size.height;
-    }
-  }
+  // TODO: Rewrite this.
+  CRU_UNUSED(content_rect);
+  throw std::runtime_error("Not implemented.");
+
+  // auto calculate_anchor = [](int alignment, float start_point,
+  //                            float total_length,
+  //                            float content_length) -> float {
+  //   switch (alignment) {
+  //     case internal::align_start:
+  //       return start_point;
+  //     case internal::align_center:
+  //       return start_point + (total_length - content_length) / 2.0f;
+  //     case internal::align_end:
+  //       return start_point + total_length - content_length;
+  //     default:
+  //       return start_point;
+  //   }
+  // };
+
+  // const auto& children = GetChildren();
+  // if (direction_ == FlexDirection::Horizontal ||
+  //     direction_ == FlexDirection::HorizontalReverse) {
+  //   float actual_content_width = 0;
+  //   for (const auto child : children) {
+  //     actual_content_width += child->GetMeasuredSize().width;
+  //   }
+
+  //   const float content_anchor_x =
+  //       calculate_anchor(static_cast<int>(content_main_align_), 0,
+  //                        content_rect.width, actual_content_width);
+
+  //   float anchor_x = 0;
+  //   for (int i = 0; i < static_cast<int>(children.size()); i++) {
+  //     const auto child = children[i];
+  //     const auto size = child->GetMeasuredSize();
+
+  //     float real_anchor_x = anchor_x + content_anchor_x;
+  //     if (direction_ == FlexDirection::Horizontal)
+  //       real_anchor_x = content_rect.left + real_anchor_x;
+  //     else
+  //       real_anchor_x = content_rect.GetRight() - real_anchor_x;
+  //     child->Layout(Rect{
+  //         real_anchor_x,
+  //         calculate_anchor(
+  //             static_cast<int>(GetChildLayoutData(i)->cross_alignment.value_or(
+  //                 this->item_cross_align_)),
+  //             content_rect.top, content_rect.height, size.height),
+  //         size.width, size.height});
+
+  //     anchor_x += size.width;
+  //   }
+  // } else {
+  //   float actual_content_height = 0;
+  //   for (const auto child : children) {
+  //     actual_content_height = child->GetMeasuredSize().height;
+  //   }
+
+  //   const float content_anchor_y =
+  //       calculate_anchor(static_cast<int>(content_main_align_), 0,
+  //                        content_rect.height, actual_content_height);
+
+  //   float anchor_y = 0;
+  //   for (int i = 0; i < static_cast<int>(children.size()); i++) {
+  //     const auto child = children[i];
+  //     const auto size = child->GetMeasuredSize();
+
+  //     float real_anchor_y = anchor_y + content_anchor_y;
+  //     if (direction_ == FlexDirection::Vertical) {
+  //       real_anchor_y = content_rect.top + real_anchor_y;
+  //     } else {
+  //       real_anchor_y = content_rect.GetBottom() - real_anchor_y;
+  //     }
+  //     child->Layout(Rect{
+  //         real_anchor_y,
+  //         calculate_anchor(
+  //             static_cast<int>(GetChildLayoutData(i)->cross_alignment.value_or(
+  //                 this->item_cross_align_)),
+  //             content_rect.left, content_rect.width, size.width),
+  //         size.width, size.height});
+
+  //     anchor_y += size.height;
+  //   }
+  // }
 }
 }  // namespace cru::ui::render
diff --git a/src/ui/render/LayoutUtility.cpp b/src/ui/render/LayoutUtility.cpp
deleted file mode 100644
index 03252f1c..00000000
--- a/src/ui/render/LayoutUtility.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "cru/ui/render/LayoutUtility.hpp"
-
-#include <algorithm>
-
-namespace cru::ui::render {
-Size Min(const Size& left, const Size& right) {
-  return Size{std::min(left.width, right.width),
-              std::min(left.height, right.height)};
-}
-
-Size Max(const Size& left, const Size& right) {
-  return Size{std::max(left.width, right.width),
-              std::max(left.height, right.height)};
-}
-}  // namespace cru::ui::render
diff --git a/src/ui/render/RenderObject.cpp b/src/ui/render/RenderObject.cpp
index abd5e1c4..ac38c6b5 100644
--- a/src/ui/render/RenderObject.cpp
+++ b/src/ui/render/RenderObject.cpp
@@ -57,20 +57,23 @@ Point RenderObject::FromRootToContent(const Point& point) const {
                point.y - (offset.y + rect.top)};
 }
 
-void RenderObject::Measure(const MeasureRequirement& requirement) {
-  measured_size_ = OnMeasureCore(requirement);
+void RenderObject::Measure(const MeasureRequirement& requirement,
+                           const MeasureSize& preferred_size) {
+  MeasureRequirement merged_requirement =
+      MeasureRequirement::Merge(requirement, custom_measure_requirement_)
+          .Normalize();
+  MeasureSize merged_preferred_size =
+      preferred_size.OverrideBy(preferred_size_);
 
-  Ensures(measured_size_.width >= 0);
-  Ensures(measured_size_.height >= 0);
-  Ensures(requirement.Satisfy(measured_size_));
+  size_ = OnMeasureCore(merged_requirement, merged_preferred_size);
+  Ensures(size_.width >= 0);
+  Ensures(size_.height >= 0);
+  Ensures(requirement.Satisfy(size_));
 }
 
-void RenderObject::Layout(const Rect& rect) {
-  Expects(rect.width >= 0);
-  Expects(rect.height >= 0);
-  offset_ = rect.GetLeftTop();
-  size_ = rect.GetSize();
-  OnLayoutCore(rect.GetSize());
+void RenderObject::Layout(const Point& offset) {
+  offset_ = offset;
+  OnLayoutCore();
 }
 
 RenderObject* RenderObject::GetSingleChild() const {
@@ -104,7 +107,8 @@ void RenderObject::OnRemoveChild(RenderObject* removed_child, Index position) {
   InvalidatePaint();
 }
 
-Size RenderObject::OnMeasureCore(const MeasureRequirement& requirement) {
+Size RenderObject::OnMeasureCore(const MeasureRequirement& requirement,
+                                 const MeasureSize& preferred_size) {
   const Size space_size{
       margin_.GetHorizontalTotal() + padding_.GetHorizontalTotal(),
       margin_.GetVerticalTotal() + padding_.GetVerticalTotal()};
@@ -113,58 +117,74 @@ Size RenderObject::OnMeasureCore(const MeasureRequirement& requirement) {
 
   MeasureRequirement content_requirement = requirement;
 
-  if (!requirement.max_width.IsNotSpecify()) {
-    const auto max_width = requirement.max_width.GetLength();
+  if (!requirement.max.width.IsNotSpecified()) {
+    const auto max_width = requirement.max.width.GetLengthOrMax();
     if (coerced_space_size.width > max_width) {
       log::Warn(
-          "Measure: horizontal length of padding and margin is bigger than "
-          "available length.");
+          "RenderObject: During measure, horizontal length of padding and "
+          "margin is bigger than required max length.");
       coerced_space_size.width = max_width;
     }
-    content_requirement.max_width = max_width - coerced_space_size.width;
+    content_requirement.max.width = max_width - coerced_space_size.width;
   }
 
-  if (!requirement.max_height.IsNotSpecify()) {
-    const auto max_height = requirement.max_height.GetLength();
+  if (!requirement.min.width.IsNotSpecified()) {
+    const auto min_width = requirement.min.width.GetLengthOr0();
+    content_requirement.min.width = std::max(0.f, min_width - space_size.width);
+  }
+
+  if (!requirement.max.height.IsNotSpecified()) {
+    const auto max_height = requirement.max.height.GetLengthOrMax();
     if (coerced_space_size.height > max_height) {
       log::Warn(
-          "Measure: horizontal length of padding and margin is bigger than "
-          "available length.");
+          "RenderObject: During measure, vertical length of padding and "
+          "margin is bigger than required max length.");
       coerced_space_size.height = max_height;
     }
-    content_requirement.max_height = max_height - coerced_space_size.height;
+    content_requirement.max.height = max_height - coerced_space_size.height;
   }
 
-  const auto content_size = OnMeasureContent(content_requirement);
+  if (!requirement.min.height.IsNotSpecified()) {
+    const auto min_height = requirement.min.height.GetLengthOr0();
+    content_requirement.min.height =
+        std::max(0.f, min_height - space_size.height);
+  }
+
+  MeasureSize content_preferred_size =
+      content_requirement.Coerce(preferred_size.Minus(space_size));
+
+  const auto content_size =
+      OnMeasureContent(content_requirement, content_preferred_size);
 
   return coerced_space_size + content_size;
 }
 
-void RenderObject::OnLayoutCore(const Size& size) {
+void RenderObject::OnLayoutCore() {
+  Size total_size = GetSize();
   Size space_size{margin_.GetHorizontalTotal() + padding_.GetHorizontalTotal(),
                   margin_.GetVerticalTotal() + padding_.GetVerticalTotal()};
 
-  auto content_size = size - space_size;
+  auto content_size = total_size - space_size;
 
   if (content_size.width < 0) {
     log::Warn(
-        "Layout: horizontal length of padding and margin is bigger than "
-        "available length.");
+        "RenderObject: During layout, horizontal length of padding and margin "
+        "is bigger than available length.");
     content_size.width = 0;
   }
   if (content_size.height < 0) {
     log::Warn(
-        "Layout: vertical length of padding and margin is bigger than "
-        "available length.");
+        "RenderObject: During layout, vertical length of padding and margin "
+        "is bigger than available length.");
     content_size.height = 0;
   }
 
   Point lefttop{margin_.left + padding_.left, margin_.top + padding_.top};
-  if (lefttop.x > size.width) {
-    lefttop.x = size.width;
+  if (lefttop.x > total_size.width) {
+    lefttop.x = total_size.width;
   }
-  if (lefttop.y > size.height) {
-    lefttop.y = size.height;
+  if (lefttop.y > total_size.height) {
+    lefttop.y = total_size.height;
   }
 
   const Rect content_rect{lefttop, content_size};
diff --git a/src/ui/render/ScrollRenderObject.cpp b/src/ui/render/ScrollRenderObject.cpp
index 98254690..e4cc27f3 100644
--- a/src/ui/render/ScrollRenderObject.cpp
+++ b/src/ui/render/ScrollRenderObject.cpp
@@ -2,7 +2,6 @@
 
 #include "cru/platform/graph/Painter.hpp"
 #include "cru/platform/graph/util/Painter.hpp"
-#include "cru/ui/render/LayoutUtility.hpp"
 
 #include <algorithm>
 
@@ -67,23 +66,32 @@ void ScrollRenderObject::SetScrollOffset(const Point& offset) {
   InvalidateLayout();
 }
 
-Size ScrollRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
-  if (const auto child = GetSingleChild()) {
-    child->Measure(MeasureRequirement::Infinate());
-    const auto preferred_size = child->GetMeasuredSize();
-    return Min(preferred_size, requirement.GetMaxSize());
-  } else {
-    return Size{};
-  }
+Size ScrollRenderObject::OnMeasureContent(const MeasureRequirement& requirement,
+                                          const MeasureSize& preferred_size) {
+  // TODO: Rewrite this.
+  CRU_UNUSED(requirement);
+  CRU_UNUSED(preferred_size);
+  throw std::runtime_error("Not implemented.");
+
+  // if (const auto child = GetSingleChild()) {
+  //   child->Measure(MeasureRequirement::Infinate());
+  //   const auto preferred_size = child->GetMeasuredSize();
+  //   return Min(preferred_size, requirement.GetMaxSize());
+  // } else {
+  //   return Size{};
+  // }
 }  // namespace cru::ui::render
 
 void ScrollRenderObject::OnLayoutContent(const Rect& content_rect) {
-  if (const auto child = GetSingleChild()) {
-    const auto child_size = child->GetMeasuredSize();
-    const auto true_scroll =
-        CoerceScroll(scroll_offset_, content_rect.GetSize(), child_size);
-    child->Layout(Rect{content_rect.GetLeftTop() - true_scroll, child_size});
-  }
+  // TODO: Rewrite this.
+  CRU_UNUSED(content_rect);
+  throw std::runtime_error("Not implemented.");
+
+  // if (const auto child = GetSingleChild()) {
+  //   const auto child_size = child->GetMeasuredSize();
+  //   const auto true_scroll =
+  //       CoerceScroll(scroll_offset_, content_rect.GetSize(), child_size);
+  //   child->Layout(Rect{content_rect.GetLeftTop() - true_scroll, child_size});
+  // }
 }
 }  // namespace cru::ui::render
diff --git a/src/ui/render/StackLayoutRenderObject.cpp b/src/ui/render/StackLayoutRenderObject.cpp
index 7dce1a83..b953ae7e 100644
--- a/src/ui/render/StackLayoutRenderObject.cpp
+++ b/src/ui/render/StackLayoutRenderObject.cpp
@@ -4,47 +4,57 @@
 
 namespace cru::ui::render {
 Size StackLayoutRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
-  auto size = Size{};
-  for (const auto child : GetChildren()) {
-    child->Measure(requirement);
-    const auto& measure_result = child->GetMeasuredSize();
-    size.width = std::max(size.width, measure_result.width);
-    size.height = std::max(size.height, measure_result.height);
-  }
-  return size;
+    const MeasureRequirement& requirement, const MeasureSize& preferred_size) {
+  // TODO: Rewrite this.
+  CRU_UNUSED(requirement);
+  CRU_UNUSED(preferred_size);
+  throw std::runtime_error("Not implemented.");
+
+  // throw std::runtime_error("Not implemented.");
+  // auto size = Size{};
+  // for (const auto child : GetChildren()) {
+  //   child->Measure(requirement);
+  //   const auto& measure_result = child->GetMeasuredSize();
+  //   size.width = std::max(size.width, measure_result.width);
+  //   size.height = std::max(size.height, measure_result.height);
+  // }
+  // return size;
 }
 
-void StackLayoutRenderObject::OnLayoutContent(const Rect& rect) {
-  auto calculate_anchor = [](int alignment, float start_point,
-                             float total_length,
-                             float content_length) -> float {
-    switch (alignment) {
-      case internal::align_start:
-        return start_point;
-      case internal::align_center:
-        return start_point + (total_length - content_length) / 2.0f;
-      case internal::align_end:
-        return start_point + total_length - content_length;
-      default:
-        return start_point;
-    }
-  };
+void StackLayoutRenderObject::OnLayoutContent(const Rect& content_rect) {
+  // TODO: Rewrite this.
+  CRU_UNUSED(content_rect);
+  throw std::runtime_error("Not implemented.");
 
-  const auto count = GetChildCount();
-  const auto& children = GetChildren();
+  // auto calculate_anchor = [](int alignment, float start_point,
+  //                            float total_length,
+  //                            float content_length) -> float {
+  //   switch (alignment) {
+  //     case internal::align_start:
+  //       return start_point;
+  //     case internal::align_center:
+  //       return start_point + (total_length - content_length) / 2.0f;
+  //     case internal::align_end:
+  //       return start_point + total_length - content_length;
+  //     default:
+  //       return start_point;
+  //   }
+  // };
 
-  for (int i = 0; i < count; i++) {
-    const auto layout_data = GetChildLayoutData(i);
-    const auto child = children[i];
-    const auto& size = child->GetMeasuredSize();
-    child->Layout(
-        Rect{calculate_anchor(static_cast<int>(layout_data->horizontal),
-                              rect.left, rect.width, size.width),
-             calculate_anchor(static_cast<int>(layout_data->vertical), rect.top,
-                              rect.height, size.height),
-             size.width, size.height});
-  }
-}
+  // const auto count = GetChildCount();
+  // const auto& children = GetChildren();
 
+  // for (int i = 0; i < count; i++) {
+  //   const auto layout_data = GetChildLayoutData(i);
+  //   const auto child = children[i];
+  //   const auto& size = child->GetMeasuredSize();
+  //   child->Layout(
+  //       Rect{calculate_anchor(static_cast<int>(layout_data->horizontal),
+  //                             rect.left, rect.width, size.width),
+  //            calculate_anchor(static_cast<int>(layout_data->vertical),
+  //            rect.top,
+  //                             rect.height, size.height),
+  //            size.width, size.height});
+  // }
+}
 }  // namespace cru::ui::render
diff --git a/src/ui/render/TextRenderObject.cpp b/src/ui/render/TextRenderObject.cpp
index ececfbc2..9cae65d6 100644
--- a/src/ui/render/TextRenderObject.cpp
+++ b/src/ui/render/TextRenderObject.cpp
@@ -1,10 +1,10 @@
 #include "cru/ui/render/TextRenderObject.hpp"
 
 #include "../Helper.hpp"
+#include "cru/common/Logger.hpp"
 #include "cru/platform/graph/Factory.hpp"
 #include "cru/platform/graph/TextLayout.hpp"
 #include "cru/platform/graph/util/Painter.hpp"
-#include "cru/ui/render/LayoutUtility.hpp"
 
 #include <algorithm>
 #include <limits>
@@ -160,10 +160,44 @@ RenderObject* TextRenderObject::HitTest(const Point& point) {
   return padding_rect.IsPointInside(point) ? this : nullptr;
 }
 
-Size TextRenderObject::OnMeasureContent(const MeasureRequirement& requirement) {
-  text_layout_->SetMaxWidth(requirement.max_height.GetLength());
-  text_layout_->SetMaxHeight(requirement.max_height.GetLength());
-  return Min(text_layout_->GetTextBounds().GetSize(), requirement.GetMaxSize());
+Size TextRenderObject::OnMeasureContent(const MeasureRequirement& requirement,
+                                        const MeasureSize& preferred_size) {
+  float measure_width;
+  if (preferred_size.width.IsSpecified())
+    measure_width = preferred_size.width.GetLengthOrUndefined();
+  else
+    measure_width = preferred_size.width.GetLengthOrMax();
+
+  text_layout_->SetMaxWidth(measure_width);
+  text_layout_->SetMaxHeight(std::numeric_limits<float>::max());
+
+  const auto text_size = text_layout_->GetTextBounds().GetSize();
+  auto result = text_size;
+
+  if (requirement.max.width.IsSpecified() &&
+      text_size.width > requirement.max.width.GetLengthOrUndefined()) {
+    log::Warn(
+        "TextRenderObject: Text actual width exceeds the required max width.");
+    result.width = requirement.max.width.GetLengthOrUndefined();
+  } else {
+    result.width = std::max(result.width, preferred_size.width.GetLengthOr0());
+    result.width = std::max(result.width, requirement.min.width.GetLengthOr0());
+  }
+
+  if (requirement.max.height.IsSpecified() &&
+      text_size.height > requirement.max.height.GetLengthOrUndefined()) {
+    log::Warn(
+        "TextRenderObject: Text actual height exceeds the required max "
+        "height.");
+    result.width = requirement.max.width.GetLengthOrUndefined();
+  } else {
+    result.height =
+        std::max(result.height, preferred_size.height.GetLengthOr0());
+    result.width =
+        std::max(result.height, requirement.min.height.GetLengthOr0());
+  }
+
+  return result;
 }
 
 void TextRenderObject::OnLayoutContent(const Rect& content_rect) {
diff --git a/src/ui/render/WindowRenderObject.cpp b/src/ui/render/WindowRenderObject.cpp
index 28afe01d..a2c7ae4d 100644
--- a/src/ui/render/WindowRenderObject.cpp
+++ b/src/ui/render/WindowRenderObject.cpp
@@ -34,17 +34,17 @@ RenderObject* WindowRenderObject::HitTest(const Point& point) {
   return Rect{Point{}, GetSize()}.IsPointInside(point) ? this : nullptr;
 }
 
-Size WindowRenderObject::OnMeasureContent(
-    const MeasureRequirement& requirement) {
+Size WindowRenderObject::OnMeasureContent(const MeasureRequirement& requirement,
+                                          const MeasureSize& preferred_size) {
   if (const auto child = GetChild()) {
-    child->Measure(requirement);
-    return child->GetMeasuredSize();
+    child->Measure(requirement, preferred_size);
+    return child->GetSize();
   } else {
     return Size{};
   }
 }
 
 void WindowRenderObject::OnLayoutContent(const Rect& content_rect) {
-  if (const auto child = GetChild()) child->Layout(content_rect);
+  if (const auto child = GetChild()) child->Layout(content_rect.GetLeftTop());
 }
 }  // namespace cru::ui::render