refactor(menu_widget): separate scrollable_widget for handling scrolling

Author: std-microblock

src/shell/contextmenu/menu_widget.cc

@@ -303,10 +303,8 @@ void mb_shell::menu_widget::update(ui::update_context &ctx) {
     bg_submenu->update(forkctx_1);
   }
 
-  // Update scrollable children (item_widgets) through base class
   scrollable_widget::update(ctx);
 
-  // Set width for all items
   for (auto &item : item_widgets) {
     item->width->reset_to(*width);
   }
@@ -520,7 +518,6 @@ void mb_shell::menu_widget::render(ui::nanovg_context ctx) {
     bg->render(ctx);
   }
 
-  // Render scrollable content (item_widgets) through base class
   scrollable_widget::render(ctx);
 
   auto ctx2 = ctx.with_offset(*x, *y);

src/shell/contextmenu/menu_widget.h

@@ -11,6 +11,7 @@
 #include <memory>
 #include <optional>
 #include "shell/widgets/background_widget.h"
+#include "scrollable_widget.h"
 
 namespace mb_shell {
 
@@ -92,21 +93,20 @@ enum class popup_direction {
   bottom_right,
 };
 struct menu_item_widget;
-struct menu_widget : public ui::widget_flex {
-  using super = ui::widget_flex;
+struct menu_widget : public scrollable_widget {
+  using super = scrollable_widget;
   float bg_padding_vertical = 6;
 
-  float max_height = 99999;
-  float actual_height = 0;
-  ui::sp_anim_float scroll_top =
-      anim_float(0, 200, ui::easing_type::ease_in_out);
   std::shared_ptr<background_widget> bg;
 
   std::shared_ptr<background_widget> bg_submenu;
   std::shared_ptr<menu_widget> current_submenu;
   std::optional<std::weak_ptr<ui::widget>> parent_item_widget;
   std::vector<std::shared_ptr<widget>> rendering_submenus;
-  std::vector<std::shared_ptr<widget>> item_widgets;
+  
+  // item_widgets is now an alias for scrollable_children from base class
+  std::vector<std::shared_ptr<widget>>& item_widgets = scrollable_children;
+  
   menu_widget *parent_menu = nullptr;
 
   menu menu_data;

src/shell/contextmenu/scrollable_widget.cc

@@ -0,0 +1,70 @@
+#include "scrollable_widget.h"
+#include "menu_render.h"
+#include "nanovg.h"
+#include "shell/config.h"
+#include <algorithm>
+
+namespace mb_shell {
+
+scrollable_widget::scrollable_widget() : super() {
+    scroll_top->set_easing(ui::easing_type::ease_in_out);
+}
+
+void scrollable_widget::update(ui::update_context &ctx) {
+    // Handle scroll input when hovered
+    if (ctx.hovered(this)) {
+        scroll_top->animate_to(
+            std::clamp(scroll_top->dest() + ctx.scroll_y * 100,
+                       height->dest() - actual_height, 0.f));
+    }
+    widget::update(ctx);
+    ctx.hovered_hit(this);
+
+    // Update scrollable children with scroll offset
+    update_scrollable_children(ctx);
+
+    // Calculate actual height and apply max_height limit
+    actual_height = height->dest();
+    height->reset_to(std::min(max_height, height->dest()));
+}
+
+void scrollable_widget::render(ui::nanovg_context ctx) {
+    super::render(ctx);
+
+    render_scrollable_children(ctx);
+    render_scrollbar(ctx);
+}
+
+void scrollable_widget::update_scrollable_children(ui::update_context &ctx) {
+    auto forkctx = ctx.with_offset(*x, *y + *scroll_top);
+    update_children(forkctx, scrollable_children);
+    reposition_children_flex(forkctx, scrollable_children);
+}
+
+void scrollable_widget::render_scrollable_children(ui::nanovg_context ctx) {
+    ctx.transaction([&] {
+        ctx.scissor(*x, *y, *width, *height);
+        render_children(ctx.with_offset(*x, *y + *scroll_top),
+                        scrollable_children);
+    });
+}
+
+void scrollable_widget::render_scrollbar(ui::nanovg_context ctx) {
+    // Only render scrollbar if content height exceeds visible height
+    if (height->dest() < actual_height) {
+        auto scrollbar_width =
+            config::current->context_menu.theme.scrollbar_width;
+        auto scrollbar_height = height->dest() * height->dest() / actual_height;
+        auto scrollbar_x = width->dest() - scrollbar_width - 2 + *x;
+        auto scrollbar_y = *y - *scroll_top / (actual_height - height->dest()) *
+                                    (height->dest() - scrollbar_height);
+
+        float c = menu_render::current.value()->light_color ? 0 : 1;
+        ctx.fillColor(nvgRGBAf(c, c, c, 0.1));
+        ctx.fillRoundedRect(
+            scrollbar_x, scrollbar_y, scrollbar_width, scrollbar_height,
+            config::current->context_menu.theme.scrollbar_radius);
+    }
+}
+
+} // namespace mb_shell

src/shell/contextmenu/scrollable_widget.h

@@ -0,0 +1,33 @@
+#pragma once
+#include "breeze_ui/animator.h"
+#include "breeze_ui/nanovg_wrapper.h"
+#include "breeze_ui/ui.h"
+#include "breeze_ui/widget.h"
+#include <memory>
+#include <vector>
+
+namespace mb_shell {
+
+/**
+ * A widget that provides scrollable content with vertical scrollbar
+ * Handles scroll input and renders a scrollbar when content exceeds max_height
+ */
+struct scrollable_widget : public ui::widget_flex {
+  using super = ui::widget_flex;
+
+  float max_height = 99999;
+  float actual_height = 0;
+  ui::sp_anim_float scroll_top =
+      anim_float(0, 200, ui::easing_type::ease_in_out);
+  std::vector<std::shared_ptr<ui::widget>> scrollable_children;
+
+  scrollable_widget();
+
+  void update(ui::update_context &ctx) override;
+  void render(ui::nanovg_context ctx) override;
+  void update_scrollable_children(ui::update_context &ctx);
+  void render_scrollable_children(ui::nanovg_context ctx);
+  void render_scrollbar(ui::nanovg_context ctx);
+};
+
+} // namespace mb_shell