aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/cru/platform/graphics/Factory.hpp8
-rw-r--r--include/cru/ui/controls/TextHostControlService.hpp2
-rw-r--r--include/cru/ui/events/UiEvent.hpp1
-rw-r--r--include/cru/ui/render/ScrollBar.hpp93
-rw-r--r--include/cru/ui/render/ScrollRenderObject.hpp15
-rw-r--r--src/ui/events/UiEvent.cpp4
-rw-r--r--src/ui/render/ScrollBar.cpp446
-rw-r--r--src/ui/render/ScrollRenderObject.cpp33
8 files changed, 532 insertions, 70 deletions
diff --git a/include/cru/platform/graphics/Factory.hpp b/include/cru/platform/graphics/Factory.hpp
index d1b37783..f9018e13 100644
--- a/include/cru/platform/graphics/Factory.hpp
+++ b/include/cru/platform/graphics/Factory.hpp
@@ -21,5 +21,11 @@ struct IGraphFactory : virtual INativeResource {
virtual std::unique_ptr<ITextLayout> CreateTextLayout(
std::shared_ptr<IFont> font, std::u16string text) = 0;
+
+ std::unique_ptr<ISolidColorBrush> CreateSolidColorBrush(const Color& color) {
+ std::unique_ptr<ISolidColorBrush> brush = CreateSolidColorBrush();
+ brush->SetColor(color);
+ return brush;
+ }
};
-} // namespace cru::platform::graph
+} // namespace cru::platform::graphics
diff --git a/include/cru/ui/controls/TextHostControlService.hpp b/include/cru/ui/controls/TextHostControlService.hpp
index 9e6a08bc..340228fe 100644
--- a/include/cru/ui/controls/TextHostControlService.hpp
+++ b/include/cru/ui/controls/TextHostControlService.hpp
@@ -100,7 +100,7 @@ class TextHostControlService : public Object {
void SetupOneHandler(event::RoutedEvent<TArgs>* (Control::*event)(),
void (TextHostControlService::*handler)(
typename event::RoutedEvent<TArgs>::EventArgs)) {
- this->event_guard_ += (this->control_->*event)()->Direct()->AddHandler(
+ this->event_guard_ += (this->control_->*event)()->Bubble()->AddHandler(
std::bind(handler, this, std::placeholders::_1));
}
diff --git a/include/cru/ui/events/UiEvent.hpp b/include/cru/ui/events/UiEvent.hpp
index 660b33f5..22ad0150 100644
--- a/include/cru/ui/events/UiEvent.hpp
+++ b/include/cru/ui/events/UiEvent.hpp
@@ -84,6 +84,7 @@ class MouseEventArgs : public UiEventArgs {
// This point is relative to window client lefttop.
Point GetPoint() const { return point_.value_or(Point{}); }
+ Point GetPoint(render::RenderObject* render_target) const;
Point GetPointToContent(render::RenderObject* render_target) const;
private:
diff --git a/include/cru/ui/render/ScrollBar.hpp b/include/cru/ui/render/ScrollBar.hpp
index a9be49a3..e3dabb57 100644
--- a/include/cru/ui/render/ScrollBar.hpp
+++ b/include/cru/ui/render/ScrollBar.hpp
@@ -15,25 +15,27 @@
namespace cru::ui::render {
class ScrollRenderObject;
-enum class ScrollKind { Absolute, Page, Line };
+enum class ScrollKind { Absolute, Relative, Page, Line };
struct Scroll {
Direction direction;
ScrollKind kind;
- float offset;
+ // For absolute, the new scroll position. Otherwise, offset.
+ float value;
};
enum class ScrollBarAreaKind {
UpArrow, // Line up
DownArrow, // Line down
- UpThumb, // Page up
- DownThumb, // Page down
+ UpSlot, // Page up
+ DownSlot, // Page down
Thumb
};
class ScrollBar : public Object {
public:
- explicit ScrollBar(gsl::not_null<ScrollRenderObject*> render_object);
+ ScrollBar(gsl::not_null<ScrollRenderObject*> render_object,
+ Direction direction);
CRU_DELETE_COPY(ScrollBar)
CRU_DELETE_MOVE(ScrollBar)
@@ -41,12 +43,15 @@ class ScrollBar : public Object {
~ScrollBar() override = default;
public:
+ Direction GetDirection() const { return direction_; }
+
bool IsEnabled() const { return is_enabled_; }
void SetEnabled(bool value);
- void Draw(platform::graphics::IPainter* painter);
+ bool IsExpanded() const { return is_expanded_; }
+ void SetExpanded(bool value);
- virtual std::optional<ScrollBarAreaKind> HitTest(const Point& point) = 0;
+ void Draw(platform::graphics::IPainter* painter);
IEvent<Scroll>* ScrollAttemptEvent() { return &scroll_attempt_event_; }
@@ -54,20 +59,54 @@ class ScrollBar : public Object {
void UninstallHandlers() { InstallHandlers(nullptr); }
gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
- GetCollapseThumbBrush() const;
+ GetCollapsedThumbBrush() const;
+ gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ GetExpandedThumbBrush() const;
+ gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ GetExpandedSlotBrush() const;
+ gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ GetExpandedArrowBrush() const;
+ gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ GetExpandedArrowBackgroundBrush() const;
protected:
- virtual void OnDraw(platform::graphics::IPainter* painter, bool expand) = 0;
+ void OnDraw(platform::graphics::IPainter* painter, bool expand);
+
+ virtual void DrawUpArrow(platform::graphics::IPainter* painter,
+ const Rect& area) = 0;
+ virtual void DrawDownArrow(platform::graphics::IPainter* painter,
+ const Rect& area) = 0;
+
+ std::optional<ScrollBarAreaKind> ExpandedHitTest(const Point& point);
+
+ virtual bool IsShowBar() = 0;
+
+ virtual std::optional<Rect> GetExpandedAreaRect(
+ ScrollBarAreaKind area_kind) = 0;
+ virtual std::optional<Rect> GetCollapsedTriggerExpandAreaRect() = 0;
+ virtual std::optional<Rect> GetCollapsedThumbRect() = 0;
+
+ virtual float CalculateNewScrollPosition(const Rect& thumb_original_rect,
+ const Point& mouse_offset) = 0;
protected:
gsl::not_null<ScrollRenderObject*> render_object_;
private:
+ Direction direction_;
+
bool is_enabled_ = true;
bool is_expanded_ = false;
- std::shared_ptr<platform::graphics::IBrush> collapse_thumb_brush_;
+ std::shared_ptr<platform::graphics::IBrush> collapsed_thumb_brush_;
+ std::shared_ptr<platform::graphics::IBrush> expanded_thumb_brush_;
+ std::shared_ptr<platform::graphics::IBrush> expanded_slot_brush_;
+ std::shared_ptr<platform::graphics::IBrush> expanded_arrow_brush_;
+ std::shared_ptr<platform::graphics::IBrush> expanded_arrow_background_brush_;
+
+ Rect move_thumb_thumb_original_rect_;
+ std::optional<Point> move_thumb_start_;
EventRevokerListGuard event_guard_;
@@ -84,11 +123,20 @@ class HorizontalScrollBar : public ScrollBar {
~HorizontalScrollBar() override = default;
- public:
- std::optional<ScrollBarAreaKind> HitTest(const Point& point) override;
-
protected:
- void OnDraw(platform::graphics::IPainter* painter, bool expand) override;
+ void DrawUpArrow(platform::graphics::IPainter* painter,
+ const Rect& area) override;
+ void DrawDownArrow(platform::graphics::IPainter* painter,
+ const Rect& area) override;
+
+ bool IsShowBar() override;
+
+ std::optional<Rect> GetExpandedAreaRect(ScrollBarAreaKind area_kind) override;
+ std::optional<Rect> GetCollapsedTriggerExpandAreaRect() override;
+ std::optional<Rect> GetCollapsedThumbRect() override;
+
+ float CalculateNewScrollPosition(const Rect& thumb_original_rect,
+ const Point& mouse_offset) override;
};
class VerticalScrollBar : public ScrollBar {
@@ -100,11 +148,20 @@ class VerticalScrollBar : public ScrollBar {
~VerticalScrollBar() override = default;
- public:
- std::optional<ScrollBarAreaKind> HitTest(const Point& point) override;
-
protected:
- void OnDraw(platform::graphics::IPainter* painter, bool expand) override;
+ void DrawUpArrow(platform::graphics::IPainter* painter,
+ const Rect& area) override;
+ void DrawDownArrow(platform::graphics::IPainter* painter,
+ const Rect& area) override;
+
+ bool IsShowBar() override;
+
+ std::optional<Rect> GetExpandedAreaRect(ScrollBarAreaKind area_kind) override;
+ std::optional<Rect> GetCollapsedTriggerExpandAreaRect() override;
+ std::optional<Rect> GetCollapsedThumbRect() override;
+
+ float CalculateNewScrollPosition(const Rect& thumb_original_rect,
+ const Point& mouse_offset) override;
};
// A delegate to draw scrollbar and register related events.
diff --git a/include/cru/ui/render/ScrollRenderObject.hpp b/include/cru/ui/render/ScrollRenderObject.hpp
index 6a6ef198..aed25f8e 100644
--- a/include/cru/ui/render/ScrollRenderObject.hpp
+++ b/include/cru/ui/render/ScrollRenderObject.hpp
@@ -2,6 +2,7 @@
#include "RenderObject.hpp"
#include "cru/platform/graphics/util/Painter.hpp"
+#include "cru/ui/Base.hpp"
#include "cru/ui/render/ScrollBar.hpp"
#include <memory>
@@ -29,8 +30,22 @@ class ScrollRenderObject : public RenderObject {
// Return the coerced scroll offset.
Point GetScrollOffset();
+ float GetScrollOffset(Direction direction) {
+ return direction == Direction::Horizontal ? GetScrollOffset().x
+ : GetScrollOffset().y;
+ }
void SetScrollOffset(const Point& offset);
void SetScrollOffset(std::optional<float> x, std::optional<float> y);
+ void SetScrollOffset(Direction direction, std::optional<float> value) {
+ if (direction == Direction::Horizontal) {
+ SetScrollOffset(value, std::nullopt);
+ } else {
+ SetScrollOffset(std::nullopt, value);
+ }
+ }
+
+ void Scroll(const Scroll& scroll);
+
Point GetRawScrollOffset() const { return scroll_offset_; }
// Return the viewable area rect.
diff --git a/src/ui/events/UiEvent.cpp b/src/ui/events/UiEvent.cpp
index b35f15a7..4c75f690 100644
--- a/src/ui/events/UiEvent.cpp
+++ b/src/ui/events/UiEvent.cpp
@@ -3,6 +3,10 @@
#include "cru/ui/render/RenderObject.hpp"
namespace cru::ui::event {
+Point MouseEventArgs::GetPoint(render::RenderObject* render_object) const {
+ return GetPoint() - render_object->GetTotalOffset();
+}
+
Point MouseEventArgs::GetPointToContent(
render::RenderObject* render_object) const {
return render_object->FromRootToContent(GetPoint());
diff --git a/src/ui/render/ScrollBar.cpp b/src/ui/render/ScrollBar.cpp
index 487f0b91..6096ab63 100644
--- a/src/ui/render/ScrollBar.cpp
+++ b/src/ui/render/ScrollBar.cpp
@@ -5,23 +5,44 @@
#include "cru/platform/GraphBase.hpp"
#include "cru/platform/graphics/Factory.hpp"
#include "cru/platform/graphics/Painter.hpp"
+#include "cru/platform/gui/Base.hpp"
+#include "cru/ui/Base.hpp"
+#include "cru/ui/events/UiEvent.hpp"
#include "cru/ui/render/ScrollRenderObject.hpp"
+#include "gsl/gsl_assert"
+#include <algorithm>
+#include <cassert>
#include <gsl/pointers>
#include <optional>
+#include <stdexcept>
namespace cru::ui::render {
constexpr float kScrollBarCollapseThumbWidth = 2;
+constexpr float kScrollBarCollapsedTriggerExpandAreaWidth = 5;
+constexpr float kScrollBarExpandWidth = 10;
-ScrollBar::ScrollBar(gsl::not_null<ScrollRenderObject*> render_object)
- : render_object_(render_object) {
+constexpr std::array<ScrollBarAreaKind, 5> kScrollBarAreaKindList{
+ ScrollBarAreaKind::UpArrow, ScrollBarAreaKind::DownArrow,
+ ScrollBarAreaKind::UpSlot, ScrollBarAreaKind::DownSlot,
+ ScrollBarAreaKind::Thumb};
+
+ScrollBar::ScrollBar(gsl::not_null<ScrollRenderObject*> render_object,
+ Direction direction)
+ : render_object_(render_object), direction_(direction) {
// TODO: Use theme resource and delete this.
- auto collapse_thumb_brush = GetUiApplication()
- ->GetInstance()
- ->GetGraphFactory()
- ->CreateSolidColorBrush();
- collapse_thumb_brush->SetColor(colors::gray.WithAlpha(128));
- collapse_thumb_brush_ = std::move(collapse_thumb_brush);
+
+ auto graphics_factory = GetUiApplication()->GetInstance()->GetGraphFactory();
+
+ collapsed_thumb_brush_ =
+ graphics_factory->CreateSolidColorBrush(colors::gray.WithAlpha(128));
+ expanded_thumb_brush_ = graphics_factory->CreateSolidColorBrush(colors::gray);
+ expanded_slot_brush_ =
+ graphics_factory->CreateSolidColorBrush(colors::seashell);
+ expanded_arrow_brush_ =
+ graphics_factory->CreateSolidColorBrush(colors::white);
+ expanded_arrow_background_brush_ =
+ graphics_factory->CreateSolidColorBrush(colors::black);
}
void ScrollBar::SetEnabled(bool value) {
@@ -29,6 +50,12 @@ void ScrollBar::SetEnabled(bool value) {
// TODO: Implement this.
}
+void ScrollBar::SetExpanded(bool value) {
+ if (is_expanded_ == value) return;
+ is_expanded_ = value;
+ render_object_->InvalidatePaint();
+}
+
void ScrollBar::Draw(platform::graphics::IPainter* painter) {
if (is_enabled_) {
OnDraw(painter, is_expanded_);
@@ -36,88 +63,407 @@ void ScrollBar::Draw(platform::graphics::IPainter* painter) {
}
void ScrollBar::InstallHandlers(controls::Control* control) {
- CRU_UNUSED(control);
- // TODO: Implement this.
+ event_guard_.Clear();
+ if (control != nullptr) {
+ event_guard_ += control->MouseDownEvent()->Bubble()->AddHandler(
+ [control, this](event::MouseButtonEventArgs& event) {
+ if (event.GetButton() == mouse_buttons::left && IsEnabled() &&
+ IsExpanded()) {
+ auto hit_test_result =
+ ExpandedHitTest(event.GetPoint(render_object_));
+ if (!hit_test_result) return;
+
+ switch (*hit_test_result) {
+ case ScrollBarAreaKind::UpArrow:
+ this->scroll_attempt_event_.Raise(
+ {GetDirection(), ScrollKind::Line, -1});
+ event.SetHandled();
+ break;
+ case ScrollBarAreaKind::DownArrow:
+ this->scroll_attempt_event_.Raise(
+ {GetDirection(), ScrollKind::Line, 1});
+ event.SetHandled();
+ break;
+ case ScrollBarAreaKind::UpSlot:
+ this->scroll_attempt_event_.Raise(
+ {GetDirection(), ScrollKind::Page, -1});
+ event.SetHandled();
+ break;
+ case ScrollBarAreaKind::DownSlot:
+ this->scroll_attempt_event_.Raise(
+ {GetDirection(), ScrollKind::Page, 1});
+ event.SetHandled();
+ break;
+ case ScrollBarAreaKind::Thumb: {
+ auto thumb_rect = GetExpandedAreaRect(ScrollBarAreaKind::Thumb);
+ assert(thumb_rect);
+
+ if (!control->CaptureMouse()) break;
+ move_thumb_thumb_original_rect_ = *thumb_rect;
+ move_thumb_start_ = event.GetPoint();
+ event.SetHandled();
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ });
+
+ event_guard_ += control->MouseUpEvent()->Bubble()->AddHandler(
+ [control, this](event::MouseButtonEventArgs& event) {
+ if (event.GetButton() == mouse_buttons::left && move_thumb_start_) {
+ move_thumb_start_ = std::nullopt;
+ control->ReleaseMouse();
+ event.SetHandled();
+ }
+ });
+
+ event_guard_ += control->MouseMoveEvent()->Bubble()->AddHandler(
+ [this](event::MouseEventArgs& event) {
+ if (move_thumb_start_) {
+ auto new_scroll_position = CalculateNewScrollPosition(
+ move_thumb_thumb_original_rect_,
+ event.GetPoint() - *move_thumb_start_);
+
+ this->scroll_attempt_event_.Raise(
+ {GetDirection(), ScrollKind::Absolute, new_scroll_position});
+ event.SetHandled();
+ return;
+ }
+
+ if (IsEnabled() && !IsExpanded()) {
+ auto trigger_expand_area = GetCollapsedTriggerExpandAreaRect();
+ if (trigger_expand_area &&
+ trigger_expand_area->IsPointInside(
+ event.GetPoint(this->render_object_)))
+ SetExpanded(true);
+ event.SetHandled();
+ }
+ });
+ }
}
gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
-ScrollBar::GetCollapseThumbBrush() const {
+ScrollBar::GetCollapsedThumbBrush() const {
// TODO: Read theme resource.
- return collapse_thumb_brush_;
+ return collapsed_thumb_brush_;
}
-HorizontalScrollBar::HorizontalScrollBar(
- gsl::not_null<ScrollRenderObject*> render_object)
- : ScrollBar(render_object) {}
+gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ScrollBar::GetExpandedThumbBrush() const {
+ // TODO: Read theme resource.
+ return expanded_thumb_brush_;
+}
+
+gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ScrollBar::GetExpandedSlotBrush() const {
+ // TODO: Read theme resource.
+ return expanded_slot_brush_;
+}
+
+gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ScrollBar::GetExpandedArrowBrush() const {
+ // TODO: Read theme resource.
+ return expanded_arrow_brush_;
+}
+
+gsl::not_null<std::shared_ptr<platform::graphics::IBrush>>
+ScrollBar::GetExpandedArrowBackgroundBrush() const {
+ // TODO: Read theme resource.
+ return expanded_arrow_brush_;
+}
+
+void ScrollBar::OnDraw(platform::graphics::IPainter* painter,
+ bool is_expanded) {
+ if (is_expanded) {
+ auto thumb_rect = GetExpandedAreaRect(ScrollBarAreaKind::Thumb);
+ if (thumb_rect)
+ painter->FillRectangle(*thumb_rect, GetExpandedThumbBrush().get().get());
+
+ auto slot_brush = GetExpandedSlotBrush().get().get();
+
+ auto up_slot_rect = GetExpandedAreaRect(ScrollBarAreaKind::UpSlot);
+ if (up_slot_rect) painter->FillRectangle(*up_slot_rect, slot_brush);
+
+ auto down_slot_rect = GetExpandedAreaRect(ScrollBarAreaKind::DownSlot);
+ if (down_slot_rect) painter->FillRectangle(*down_slot_rect, slot_brush);
+
+ auto up_arrow = GetExpandedAreaRect(ScrollBarAreaKind::UpArrow);
+ if (up_arrow) this->DrawUpArrow(painter, *up_arrow);
-std::optional<ScrollBarAreaKind> HorizontalScrollBar::HitTest(
+ auto down_arrow = GetExpandedAreaRect(ScrollBarAreaKind::DownArrow);
+ if (down_arrow) this->DrawUpArrow(painter, *down_arrow);
+ } else {
+ auto optional_rect = GetCollapsedThumbRect();
+ if (optional_rect) {
+ painter->FillRectangle(*optional_rect,
+ GetCollapsedThumbBrush().get().get());
+ }
+ }
+}
+
+std::optional<ScrollBarAreaKind> ScrollBar::ExpandedHitTest(
const Point& point) {
- // TODO: Implement this.
- CRU_UNUSED(point);
+ for (auto kind : kScrollBarAreaKindList) {
+ auto rect = this->GetExpandedAreaRect(kind);
+ if (rect) {
+ if (rect->IsPointInside(point)) return kind;
+ }
+ }
return std::nullopt;
}
-void HorizontalScrollBar::OnDraw(platform::graphics::IPainter* painter,
- bool expand) {
+HorizontalScrollBar::HorizontalScrollBar(
+ gsl::not_null<ScrollRenderObject*> render_object)
+ : ScrollBar(render_object, Direction::Horizontal) {}
+
+void HorizontalScrollBar::DrawUpArrow(platform::graphics::IPainter* painter,
+ const Rect& area) {
+ // TODO: Do what you must!
+ painter->FillRectangle(area, GetExpandedArrowBackgroundBrush().get().get());
+}
+
+void HorizontalScrollBar::DrawDownArrow(platform::graphics::IPainter* painter,
+ const Rect& area) {
+ // TODO: Do what you must!
+ painter->FillRectangle(area, GetExpandedArrowBackgroundBrush().get().get());
+}
+
+bool HorizontalScrollBar::IsShowBar() {
const auto child = render_object_->GetFirstChild();
- if (child == nullptr) return;
+ if (child == nullptr) return false;
const auto view_rect = render_object_->GetViewRect();
+ const auto child_size = child->GetSize();
+
+ if (view_rect.width >= child_size.width) return false;
+
+ return true;
+}
+
+std::optional<Rect> HorizontalScrollBar::GetExpandedAreaRect(
+ ScrollBarAreaKind area_kind) {
+ auto show = IsShowBar();
+ if (!show) return std::nullopt;
+
const auto padding_rect = render_object_->GetPaddingRect();
+
+ const auto child = render_object_->GetFirstChild();
+
+ const auto view_rect = render_object_->GetViewRect();
const auto child_size = child->GetSize();
- if (view_rect.width >= child_size.width) return;
+ const float start_percentage = view_rect.left / child_size.width;
+ const float length_percentage = view_rect.width / child_size.width;
+ const float end_percentage = start_percentage + length_percentage;
+
+ const float top = padding_rect.GetBottom() - kScrollBarExpandWidth;
+ const float height = kScrollBarExpandWidth;
+
+ // Without arrow.
+ const float bar_area_length = padding_rect.width - 3 * kScrollBarExpandWidth;
+ const float bar_area_start = padding_rect.left + kScrollBarExpandWidth;
+
+ switch (area_kind) {
+ case ScrollBarAreaKind::UpArrow:
+ return Rect{padding_rect.left, top, kScrollBarExpandWidth, height};
+ case ScrollBarAreaKind::DownArrow:
+ return Rect{padding_rect.GetRight() - 2 * kScrollBarExpandWidth, top,
+ kScrollBarExpandWidth, height};
+ case ScrollBarAreaKind::UpSlot:
+ return Rect{bar_area_start, top, bar_area_length * start_percentage,
+ height};
+ case ScrollBarAreaKind::DownSlot:
+ return Rect{bar_area_start + bar_area_length * end_percentage, top,
+ bar_area_length * (1 - end_percentage), height};
+ case ScrollBarAreaKind::Thumb:
+ return Rect{bar_area_start + bar_area_length * start_percentage, top,
+ bar_area_length * length_percentage, height};
+ default:
+ throw std::invalid_argument("Unsupported scroll area kind.");
+ }
+}
+
+std::optional<Rect> HorizontalScrollBar::GetCollapsedTriggerExpandAreaRect() {
+ auto show = IsShowBar();
+ if (!show) return std::nullopt;
+
+ const auto padding_rect = render_object_->GetPaddingRect();
+
+ return Rect{
+ padding_rect.left,
+ padding_rect.GetBottom() - kScrollBarCollapsedTriggerExpandAreaWidth,
+ padding_rect.width, kScrollBarCollapseThumbWidth};
+}
+
+std::optional<Rect> HorizontalScrollBar::GetCollapsedThumbRect() {
+ auto show = IsShowBar();
+ if (!show) return std::nullopt;
+
+ const auto child = render_object_->GetFirstChild();
+
+ const auto view_rect = render_object_->GetViewRect();
+ const auto child_size = child->GetSize();
const float start_percentage = view_rect.left / child_size.width;
const float length_percentage = view_rect.width / child_size.width;
// const float end_percentage = start_percentage + length_percentage;
- if (expand) {
- // TODO: Implement this.
- } else {
- Rect thumb_rect{padding_rect.left + padding_rect.width * start_percentage,
- padding_rect.GetBottom() - kScrollBarCollapseThumbWidth,
- padding_rect.width * length_percentage,
- kScrollBarCollapseThumbWidth};
- painter->FillRectangle(thumb_rect, GetCollapseThumbBrush().get().get());
- }
+ const auto padding_rect = render_object_->GetPaddingRect();
+
+ return Rect{padding_rect.left + padding_rect.width * start_percentage,
+ padding_rect.GetBottom() - kScrollBarCollapseThumbWidth,
+ padding_rect.width * length_percentage,
+ kScrollBarCollapseThumbWidth};
+}
+
+float HorizontalScrollBar::CalculateNewScrollPosition(
+ const Rect& thumb_original_rect, const Point& mouse_offset) {
+ auto new_thumb_start = thumb_original_rect.left + mouse_offset.x;
+
+ const auto padding_rect = render_object_->GetPaddingRect();
+
+ auto scroll_area_start = padding_rect.left + kScrollBarExpandWidth;
+ auto scroll_area_end = padding_rect.GetRight() - 2 * kScrollBarExpandWidth;
+
+ auto thumb_head_end = scroll_area_end - thumb_original_rect.width;
+
+ const auto child = render_object_->GetFirstChild();
+ const auto child_size = child->GetSize();
+
+ new_thumb_start =
+ std::clamp(new_thumb_start, scroll_area_start, thumb_head_end);
+
+ auto offset = new_thumb_start / (scroll_area_end - scroll_area_start) *
+ child_size.width;
+
+ return offset;
}
VerticalScrollBar::VerticalScrollBar(
gsl::not_null<ScrollRenderObject*> render_object)
- : ScrollBar(render_object) {}
+ : ScrollBar(render_object, Direction::Vertical) {}
-std::optional<ScrollBarAreaKind> VerticalScrollBar::HitTest(
- const Point& point) {
- // TODO: Implement this.
- CRU_UNUSED(point);
- return std::nullopt;
+void VerticalScrollBar::DrawUpArrow(platform::graphics::IPainter* painter,
+ const Rect& area) {
+ // TODO: Do what you must!
+ painter->FillRectangle(area, GetExpandedArrowBackgroundBrush().get().get());
+}
+
+void VerticalScrollBar::DrawDownArrow(platform::graphics::IPainter* painter,
+ const Rect& area) {
+ // TODO: Do what you must!
+ painter->FillRectangle(area, GetExpandedArrowBackgroundBrush().get().get());
+}
+
+bool VerticalScrollBar::IsShowBar() {
+ const auto child = render_object_->GetFirstChild();
+ if (child == nullptr) return false;
+
+ const auto view_rect = render_object_->GetViewRect();
+ const auto child_size = child->GetSize();
+
+ if (view_rect.height >= child_size.height) return false;
+
+ return true;
}
-void VerticalScrollBar::OnDraw(platform::graphics::IPainter* painter,
- bool expand) {
+std::optional<Rect> VerticalScrollBar::GetExpandedAreaRect(
+ ScrollBarAreaKind area_kind) {
+ auto show = IsShowBar();
+ if (!show) return std::nullopt;
+
+ const auto padding_rect = render_object_->GetPaddingRect();
+
const auto child = render_object_->GetFirstChild();
- if (child == nullptr) return;
+
+ const auto view_rect = render_object_->GetViewRect();
+ const auto child_size = child->GetSize();
+
+ const float start_percentage = view_rect.top / child_size.height;
+ const float length_percentage = view_rect.height / child_size.height;
+ const float end_percentage = start_percentage + length_percentage;
+
+ const float left = padding_rect.GetRight() - kScrollBarExpandWidth;
+ const float width = kScrollBarExpandWidth;
+
+ // Without arrow.
+ const float bar_area_length = padding_rect.height - 3 * kScrollBarExpandWidth;
+ const float bar_area_start = padding_rect.top + kScrollBarExpandWidth;
+
+ switch (area_kind) {
+ case ScrollBarAreaKind::UpArrow:
+ return Rect{left, padding_rect.top, width, kScrollBarExpandWidth};
+ case ScrollBarAreaKind::DownArrow:
+ return Rect{left, padding_rect.GetBottom() - 2 * kScrollBarExpandWidth,
+ width, kScrollBarExpandWidth};
+ case ScrollBarAreaKind::UpSlot:
+ return Rect{left, bar_area_start, width,
+ bar_area_length * start_percentage};
+ case ScrollBarAreaKind::DownSlot:
+ return Rect{left, bar_area_start + bar_area_length * end_percentage,
+ width, bar_area_length * (1 - end_percentage)};
+ case ScrollBarAreaKind::Thumb:
+ return Rect{left, bar_area_start + bar_area_length * start_percentage,
+ width, bar_area_length * length_percentage};
+ default:
+ throw std::invalid_argument("Unsupported scroll area kind.");
+ }
+}
+
+std::optional<Rect> VerticalScrollBar::GetCollapsedTriggerExpandAreaRect() {
+ auto show = IsShowBar();
+ if (!show) return std::nullopt;
+
+ const auto padding_rect = render_object_->GetPaddingRect();
+
+ return Rect{
+ padding_rect.GetRight() - kScrollBarCollapsedTriggerExpandAreaWidth,
+ padding_rect.top, kScrollBarCollapseThumbWidth, padding_rect.height};
+}
+
+std::optional<Rect> VerticalScrollBar::GetCollapsedThumbRect() {
+ const auto child = render_object_->GetFirstChild();
+ if (child == nullptr) return std::nullopt;
const auto view_rect = render_object_->GetViewRect();
const auto padding_rect = render_object_->GetPaddingRect();
const auto child_size = child->GetSize();
- if (view_rect.height >= child_size.height) return;
+ if (view_rect.height >= child_size.height) return std::nullopt;
const float start_percentage = view_rect.top / child_size.height;
const float length_percentage = view_rect.height / child_size.height;
// const float end_percentage = start_percentage + length_percentage;
- if (expand) {
- // TODO: Implement this.
- } else {
- Rect thumb_rect{padding_rect.GetRight() - kScrollBarCollapseThumbWidth,
- padding_rect.top + padding_rect.height * start_percentage,
- kScrollBarCollapseThumbWidth,
- padding_rect.height * length_percentage};
- painter->FillRectangle(thumb_rect, GetCollapseThumbBrush().get().get());
- }
+ return Rect{padding_rect.GetRight() - kScrollBarCollapseThumbWidth,
+ padding_rect.top + padding_rect.height * start_percentage,
+ kScrollBarCollapseThumbWidth,
+ padding_rect.height * length_percentage};
+}
+
+float VerticalScrollBar::CalculateNewScrollPosition(
+ const Rect& thumb_original_rect, const Point& mouse_offset) {
+ auto new_thumb_start = thumb_original_rect.top + mouse_offset.y;
+
+ const auto padding_rect = render_object_->GetPaddingRect();
+
+ auto scroll_area_start = padding_rect.top + kScrollBarExpandWidth;
+ auto scroll_area_end = padding_rect.GetBottom() - 2 * kScrollBarExpandWidth;
+
+ auto thumb_head_end = scroll_area_end - thumb_original_rect.height;
+
+ const auto child = render_object_->GetFirstChild();
+ const auto child_size = child->GetSize();
+
+ new_thumb_start =
+ std::clamp(new_thumb_start, scroll_area_start, thumb_head_end);
+
+ auto offset = new_thumb_start / (scroll_area_end - scroll_area_start) *
+ child_size.height;
+
+ return offset;
}
ScrollBarDelegate::ScrollBarDelegate(
diff --git a/src/ui/render/ScrollRenderObject.cpp b/src/ui/render/ScrollRenderObject.cpp
index a9ec729d..0a81eaab 100644
--- a/src/ui/render/ScrollRenderObject.cpp
+++ b/src/ui/render/ScrollRenderObject.cpp
@@ -2,13 +2,17 @@
#include "cru/platform/graphics/Painter.hpp"
#include "cru/platform/graphics/util/Painter.hpp"
+#include "cru/ui/Base.hpp"
#include "cru/ui/controls/Control.hpp"
#include "cru/ui/render/ScrollBar.hpp"
#include <algorithm>
#include <memory>
+#include <optional>
namespace cru::ui::render {
+constexpr float kLineHeight = 16;
+
namespace {
// This method assumes margin offset is already considered.
// It promises that it won't return negetive value.
@@ -36,6 +40,35 @@ Point CoerceScroll(const Point& scroll_offset, const Size& content_size,
ScrollRenderObject::ScrollRenderObject() : RenderObject(ChildMode::Single) {
scroll_bar_delegate_ = std::make_unique<ScrollBarDelegate>(this);
+ scroll_bar_delegate_->ScrollAttemptEvent()->AddHandler(
+ [this](const struct Scroll& scroll) { this->Scroll(scroll); });
+}
+
+void ScrollRenderObject::Scroll(const struct Scroll& scroll) {
+ auto direction = scroll.direction;
+
+ switch (scroll.kind) {
+ case ScrollKind::Absolute:
+ SetScrollOffset(direction, scroll.value);
+ break;
+ case ScrollKind::Relative:
+ SetScrollOffset(direction,
+ GetScrollOffset(scroll.direction) + scroll.value);
+ break;
+ case ScrollKind::Page:
+ SetScrollOffset(direction, GetScrollOffset(direction) +
+ (direction == Direction::Horizontal
+ ? GetViewRect().width
+ : GetViewRect().height) *
+ scroll.value);
+ break;
+ case ScrollKind::Line:
+ SetScrollOffset(direction,
+ GetScrollOffset(direction) + kLineHeight * scroll.value);
+ break;
+ default:
+ break;
+ }
}
RenderObject* ScrollRenderObject::HitTest(const Point& point) {
generated by cgit v1.2.3 (git 2.46.0) at 2025-09-28 19:04:28 +0000