[window server] Add mobile homescreen and control bar

build/userland/BUILD.gn

···
     "//userland/activity_monitor:activity_monitor",
     "//userland/cat:cat",
     "//userland/dock:dock",
+    "//userland/homescreen:homescreen",
     "//userland/init:init",
     "//userland/initgui:initgui",
     "//userland/kill:kill",

libs/libui/include/libui/View.h

···
 
 struct SafeArea {
     static const int Top = 8;
+#ifdef TARGET_DESKTOP
     static const int Bottom = 8;
+#elif TARGET_MOBILE
+    static const int Bottom = 20;
+#endif
     static const int Left = 8;
     static const int Right = 8;
 };

libs/libui/include/libui/Window.h

···
 
 enum WindowType {
     Standard = 0,
-    Dock = 1,
+    Homescreen = 1,
 };
 
 class Connection;

servers/window_server/BUILD.gn

···
   }
   if (device_type == "mobile") {
     cflags = [ "-DTARGET_MOBILE" ]
-    sources += [ "src/Mobile/Window.cpp" ]
+    sources += [
+      "src/Components/ControlBar/ControlBar.cpp",
+      "src/Mobile/Window.cpp",
+    ]
   }
 
   configs = [ "//build/userland:userland_flags" ]

servers/window_server/src/Components/Base/BaseWindow.h

···
 
 enum WindowType : int {
     Standard = 0,
-    Dock = 1,
+    Homescreen = 1,
 };
 
 enum WindowStatusUpdateType : int {

servers/window_server/src/Components/ControlBar/ControlBar.cpp

···
+/*
+ * Copyright (C) 2020-2021 Nikita Melekhin. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "ControlBar.h"
+#include "../../Compositor.h"
+#include <libg/ImageLoaders/PNGLoader.h>
+
+namespace WinServer {
+
+static ControlBar* s_the;
+
+ControlBar& ControlBar::the()
+{
+    return *s_the;
+}
+
+ControlBar::ControlBar()
+    : m_bounds(0, Screen::the().bounds().height() - height(), Screen::the().bounds().width(), height())
+{
+    s_the = this;
+    LG::PNG::PNGLoader loader;
+    m_logo = loader.load_from_file("/res/system/mobile/control.png");
+    int x = width() / 2 - m_logo.width() / 2;
+    int y = Screen::the().bounds().height() - height() + height() / 2 - m_logo.height() / 2;
+    m_button_bounds = LG::Rect(x, y, m_logo.width(), m_logo.height());
+}
+
+} // namespace WinServer

servers/window_server/src/Components/ControlBar/ControlBar.h

···
+/*
+ * Copyright (C) 2020-2021 Nikita Melekhin. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include "../../CursorManager.h"
+#include "../../Desktop/Window.h"
+#include <libfoundation/Logger.h>
+#include <libg/Context.h>
+#include <libg/PixelBitmap.h>
+#include <libg/Point.h>
+#include <vector>
+
+namespace WinServer {
+
+class ControlBar {
+public:
+    static ControlBar& the();
+    ControlBar();
+
+    static constexpr size_t height() { return 20; }
+    static constexpr size_t padding() { return 4; }
+    static constexpr size_t menubar_content_offset() { return 20; }
+
+    size_t width() const { return m_bounds.width(); }
+    LG::Rect& bounds() { return m_bounds; }
+    const LG::Rect& bounds() const { return m_bounds; }
+    const LG::Rect& control_button_bounds() const { return m_button_bounds; }
+
+    [[gnu::always_inline]] inline void draw(LG::Context& ctx)
+    {
+        ctx.draw({ control_button_bounds().min_x(), control_button_bounds().min_y() }, m_logo);
+    }
+
+private:
+    LG::Rect m_bounds;
+    LG::Rect m_button_bounds;
+    LG::PixelBitmap m_logo;
+};
+
+} // namespace WinServer

servers/window_server/src/Compositor.cpp

···
 
 #include "Compositor.h"
 #include "Components/Base/BaseWindow.h"
+#include "Components/ControlBar/ControlBar.h"
 #include "Components/MenuBar/MenuBar.h"
 #include "CursorManager.h"
 #include "ResourceManager.h"
···
     : m_cursor_manager(CursorManager::the())
     , m_resource_manager(ResourceManager::the())
     , m_menu_bar(MenuBar::the())
+#ifdef TARGET_MOBILE
+    , m_control_bar(ControlBar::the())
+#endif // TARGET_MOBILE
 {
     s_the = this;
     invalidate(Screen::the().bounds());
···
         ctx.draw(window.content_bounds().origin(), window.content_bitmap());
         ctx.reset_clip();
     };
-#endif // #ifdef TARGET_DESKTOP
+#endif // TARGET_DESKTOP
 
     for (int i = 0; i < invalidated_areas.size(); i++) {
         draw_wallpaper_for_area(invalidated_areas[i]);
···
         m_menu_bar.draw(ctx);
         ctx.reset_clip();
     }
+
+#ifdef TARGET_MOBILE
+    for (int i = 0; i < invalidated_areas.size(); i++) {
+        ctx.add_clip(invalidated_areas[i]);
+        m_control_bar.draw(ctx);
+        ctx.reset_clip();
+    }
+#endif // TARGET_MOBILE
 
     auto mouse_draw_position = m_cursor_manager.draw_position();
     auto& current_mouse_bitmap = m_cursor_manager.current_cursor();

servers/window_server/src/Compositor.h

···
 class CursorManager;
 class ResourceManager;
 class MenuBar;
+#ifdef TARGET_MOBILE
+class ControlBar;
+#endif // TARGET_MOBILE
 
 class Compositor {
 public:
···
     inline const ResourceManager& resource_manager() const { return m_resource_manager; }
     inline MenuBar& menu_bar() { return m_menu_bar; }
     inline const MenuBar& menu_bar() const { return m_menu_bar; }
+#ifdef TARGET_MOBILE
+    inline ControlBar& control_bar() { return m_control_bar; }
+    inline const ControlBar& control_bar() const { return m_control_bar; }
+#endif // TARGET_MOBILE
 
 private:
     void copy_changes_to_second_buffer(const std::vector<LG::Rect>& areas);
 
+    std::vector<LG::Rect> m_invalidated_areas;
     MenuBar& m_menu_bar;
     CursorManager& m_cursor_manager;
     ResourceManager& m_resource_manager;
-    std::vector<LG::Rect> m_invalidated_areas;
+#ifdef TARGET_MOBILE
+    ControlBar& m_control_bar;
+#endif // TARGET_MOBILE
 };
 
 } // namespace WinServer

servers/window_server/src/CursorManager.cpp

···
 {
     s_the = this;
     LG::PNG::PNGLoader loader;
+#ifdef TARGET_DESKTOP
     m_std_cursor = loader.load_from_file("/res/system/arrow.png");
+#elif TARGET_MOBILE
+    m_std_cursor = loader.load_from_file("/res/system/mobile/cursor.png");
+#endif
 }
 
 } // namespace WinServer

servers/window_server/src/CursorManager.h

···
  */
 
 #pragma once
-#include "Screen.h"
 #include "Event.h"
+#include "Screen.h"
 #include <algorithm>
 #include <libg/PixelBitmap.h>
 #include <libg/Point.h>
···
 
     inline const LG::PixelBitmap& current_cursor() const { return std_cursor(); }
     inline const LG::PixelBitmap& std_cursor() const { return m_std_cursor; }
+#ifdef TARGET_DESKTOP
     inline LG::Point<int> draw_position() { return { m_mouse_x - 2, m_mouse_y - 2 }; }
+#elif TARGET_MOBILE
+    inline LG::Point<int> draw_position() { return { m_mouse_x - 6, m_mouse_y - 6 }; }
+#endif
 
-    inline int x() const { return m_mouse_x; }
+    inline int x() const
+    {
+        return m_mouse_x;
+    }
     inline int y() const { return m_mouse_y; }
 
     template <Params param>
···
             }
             m_mouse_left_button_pressed = val;
         } else {
-            []<bool flag = false>() { static_assert(flag, "Could not call set() with such param!"); } ();
+            []<bool flag = false>() { static_assert(flag, "Could not call set() with such param!"); }
+            ();
         }
     }
 
···
         } else if constexpr (param == CursorManager::Params::LeftButton) {
             m_mask_changed_objects |= CursorManager::ChangedValues::LeftButton;
         } else {
-            []<bool flag = false>() { static_assert(flag, "Could not set_changed() for the param!"); } ();
+            []<bool flag = false>() { static_assert(flag, "Could not set_changed() for the param!"); }
+            ();
         }
     }
 
···
     } else if constexpr (param == CursorManager::Params::OffsetY) {
         return m_mouse_offset_y;
     } else {
-        []<bool flag = false>() { static_assert(flag, "Could call get() only for coords-like params!"); } ();
+        []<bool flag = false>() { static_assert(flag, "Could call get() only for coords-like params!"); }
+        ();
     }
 }
 
···
     if constexpr (param == CursorManager::Params::LeftButton) {
         return m_mouse_left_button_pressed;
     } else {
-        []<bool flag = false>() { static_assert(flag, "Could call pressed() only for buttons!"); } ();
+        []<bool flag = false>() { static_assert(flag, "Could call pressed() only for buttons!"); }
+        ();
     }
 }
 
···
     } else if constexpr (param == CursorManager::Params::Buttons) {
         return (m_mask_changed_objects & CursorManager::ChangedValues::LeftButton) | (m_mask_changed_objects & CursorManager::ChangedValues::RightButton);
     } else {
-        []<bool flag = false>() { static_assert(flag, "Could not call is_changed() for the param!"); } ();
+        []<bool flag = false>() { static_assert(flag, "Could not call is_changed() for the param!"); }
+        ();
     }
 }
 

servers/window_server/src/ServerDecoder.cpp

···
     auto* window = new Mobile::Window(msg.key(), win_id, msg);
     wm.add_window(window);
     wm.notify_window_icon_changed(window->id());
-    if (window->type() == WindowType::Standard) {
-        wm.move_window(window, 0, MenuBar::height());
-    }
+    wm.move_window(window, 0, MenuBar::height());
     return new CreateWindowMessageReply(msg.key(), win_id);
 }
 #endif
···
     if (!window || !target_window) {
         return nullptr;
     }
-    if (window->type() == WindowType::Dock) {
+    if (window->type() == WindowType::Homescreen) {
         // Only dock can ask for that now.
         wm.bring_to_front(*target_window);
     }

servers/window_server/src/WindowManager.cpp

···
 #elif TARGET_MOBILE
 void WindowManager::setup_dock(Window* window)
 {
-    window->bounds().set_y(m_screen.bounds().max_y() - window->bounds().height() + 1);
-    window->content_bounds().set_y(m_screen.bounds().max_y() - window->bounds().height() + 1);
-    window->set_event_mask(WindowEvent::IconChange | WindowEvent::WindowStatus);
     m_dock_window = window->weak_ptr();
 }
 #endif // TARGET_MOBILE
···
 {
     auto* mouse_event = (MouseEvent*)event.release();
     update_mouse_position(mouse_event);
+
+    if (m_compositor.control_bar().control_button_bounds().contains(m_cursor_manager.x(), m_cursor_manager.y()) && active_window()) {
+        if (m_cursor_manager.pressed<CursorManager::Params::LeftButton>()) {
+            remove_window(active_window().ptr());
+        }
+        goto end;
+    }
+
+    // Tap emulation
+    if (m_cursor_manager.is_changed<CursorManager::Params::Buttons>() && active_window()) {
+        auto window = active_window();
+        LG::Point<int> point(m_cursor_manager.x(), m_cursor_manager.y());
+        point.offset_by(-window->content_bounds().origin());
+        bool is_left_pressed = m_cursor_manager.pressed<CursorManager::Params::LeftButton>();
+        Logger::debug << "Tapping " << point.x() << " " << point.y() << std::endl;
+        m_event_loop.add(m_connection, new SendEvent(new MouseActionMessage(window->connection_id(), window->id(), !is_left_pressed, point.x(), point.y())));
+    }
+end:
     delete mouse_event;
 }
 #endif // TARGET_MOBILE

servers/window_server/src/WindowManager.h

···
 
 #pragma once
 #include "../shared/Connections/WSConnection.h"
+#include "Components/ControlBar/ControlBar.h"
 #include "Components/MenuBar/MenuBar.h"
 #include "Compositor.h"
 #include "Connection.h"
···
 
     inline void add_window(Window* window)
     {
-        if (window->type() == WindowType::Dock) {
+        if (window->type() == WindowType::Homescreen) {
             setup_dock(window);
         }
         m_windows.push_back(window);
···
 
     inline void remove_window(Window* window)
     {
+        if (m_dock_window.ptr() == window) {
+            return;
+        }
         if (movable_window().ptr() == window) {
             m_movable_window = nullptr;
         }
···
         m_compositor.menu_bar().set_menubar_content(&m_std_menubar_content, m_compositor);
         m_compositor.invalidate(window->bounds());
         notify_window_status_changed(window->id(), WindowStatusUpdateType::Removed);
+#ifdef TARGET_MOBILE
+        auto* top_window = get_top_standard_window_in_view();
+        if (top_window) {
+            m_active_window = top_window->weak_ptr();
+        }
+#endif
         delete window;
     }
 
···
     {
         auto* prev_window = get_top_standard_window_in_view();
         do_bring_to_front(window);
+#ifdef TARGET_DESKTOP
         if (m_dock_window) {
             do_bring_to_front(*m_dock_window);
         }
-#ifdef TARGET_DESKTOP
         window.frame().set_active(true);
         m_compositor.invalidate(window.bounds());
         if (prev_window && prev_window->id() != window.id()) {

servers/window_server/src/main.cpp

···
  * found in the LICENSE file.
  */
 
+#include "Components/ControlBar/ControlBar.h"
 #include "Components/MenuBar/MenuBar.h"
 #include "Components/MenuBar/Widgets/Clock/Clock.h"
 #include "Compositor.h"
···
 void start_dock()
 {
     if (fork()) {
+#ifdef TARGET_DESKTOP
         execve("/bin/dock", nullptr, nullptr);
+#elif TARGET_MOBILE
+        execve("/bin/homescreen", nullptr, nullptr);
+#endif
         std::abort();
     }
 }
···
     new WinServer::CursorManager();
     new WinServer::ResourceManager();
     new WinServer::MenuBar();
+#ifdef TARGET_MOBILE
+    new WinServer::ControlBar();
+#endif
     new WinServer::Compositor();
     new WinServer::WindowManager();
     new WinServer::Devices();

userland/dock/DockWindow.h

···
 class DockWindow : public UI::Window {
 public:
     DockWindow()
-        : UI::Window(LG::Size(1024, 36), UI::WindowType::Dock)
+        : UI::Window(LG::Size(1024, 36), UI::WindowType::Homescreen)
     {
     }
 

userland/homescreen/.info.mk

···
+APPS += DOCK
+
+DOCK_NAME = dock
+DOCK_LIBS = cxx ui
+DOCK_INSTALL_PATH = bin/

userland/homescreen/AppDelegate.cpp

···
+#include "HomeScreenView.h"
+#include "HomeScreenViewController.h"
+#include "HomeScreenWindow.h"
+#include <libui/AppDelegate.h>
+
+class AppDelegate : public UI::AppDelegate {
+public:
+    AppDelegate() = default;
+    virtual ~AppDelegate() = default;
+
+    LG::Size preferred_desktop_window_size() const override { return LG::Size(400, 300); }
+
+    bool application() override
+    {
+        auto& window = std::oneos::construct<HomeScreenWindow>(window_size());
+        window.set_bitmap_format(LG::PixelBitmapFormat::RGBA); // Turning on Alpha channel
+        auto& dock_view = window.create_superview<HomeScreenView, HomeScreenViewController>();
+
+        window.set_title("Homescreen");
+        return true;
+    }
+
+private:
+};
+
+SET_APP_DELEGATE(AppDelegate);

userland/homescreen/BUILD.gn

···
+import("//build/userland/TEMPLATE.gni")
+
+oneOS_executable("homescreen") {
+  install_path = "bin/"
+  sources = [
+    "AppDelegate.cpp",
+    "HomeScreenView.cpp",
+  ]
+  configs = [ "//build/userland:userland_flags" ]
+  deplibs = [
+    "libcxx",
+    "libfoundation",
+    "libg",
+    "libui",
+  ]
+}

userland/homescreen/FastLaunchEntity.h

···
+#pragma once
+#include <libg/PixelBitmap.h>
+#include <libg/string.h>
+
+class FastLaunchEntity {
+public:
+    FastLaunchEntity() = default;
+
+    void set_icon(LG::PixelBitmap&& icon) { m_icon = std::move(icon); }
+    const LG::PixelBitmap& icon() const { return m_icon; }
+
+    void set_path_to_exec(LG::string&& path) { m_path_to_exec = std::move(path); }
+    const LG::string& path_to_exec() const { return m_path_to_exec; }
+
+private:
+    LG::PixelBitmap m_icon;
+    LG::string m_path_to_exec {};
+};

userland/homescreen/HomeScreenEntity.h

···
+#pragma once
+#include <libg/PixelBitmap.h>
+
+class HomeScreenEntity {
+public:
+    HomeScreenEntity() = default;
+
+    HomeScreenEntity(int window_id)
+        : m_window_id(window_id)
+    {
+    }
+
+    bool operator==(const HomeScreenEntity& other) const { return m_window_id == other.m_window_id; }
+    bool operator!=(const HomeScreenEntity& other) const { return m_window_id != other.m_window_id; }
+
+    int window_id() const { return m_window_id; }
+    void set_icon(LG::PixelBitmap&& icon) { m_icon = std::move(icon); }
+    const LG::PixelBitmap& icon() const { return m_icon; }
+
+private:
+    int m_window_id { 0 };
+    LG::PixelBitmap m_icon;
+    int m_window_status { 0 };
+};

userland/homescreen/HomeScreenView.cpp

···
+#include "HomeScreenView.h"
+#include <algorithm>
+#include <cstdlib>
+#include <libfoundation/EventLoop.h>
+#include <libfoundation/KeyboardMapping.h>
+#include <libg/Color.h>
+#include <libg/ImageLoaders/PNGLoader.h>
+#include <libui/App.h>
+#include <libui/Context.h>
+#include <unistd.h>
+
+static HomeScreenView* this_view;
+static int icons_per_line = 4;
+static int icons_per_column = 5;
+
+HomeScreenView::HomeScreenView(View* superview, const LG::Rect& frame)
+    : View(superview, frame)
+{
+}
+
+void HomeScreenView::display(const LG::Rect& rect)
+{
+    // FIXME: Rendering is a bit studip now, will rewrite it
+    //        completely when stackview is available.
+    UI::Context ctx(*this);
+    ctx.add_clip(rect);
+
+    ctx.set_fill_color(LG::Color(222, 222, 222, 0));
+    ctx.fill(bounds());
+
+    // Drawing launched icons
+    int spacing_x = (bounds().width() - 48 * icons_per_line) / 6;
+    int spacing_y = (bounds().height() - 48 * icons_per_column) / 7;
+    int offsetx = spacing_x + 4;
+    int offsety = spacing_y;
+    int drawn = 0;
+    for (auto& entity : m_fast_launch_entites) {
+        ctx.draw({ offsetx, offsety }, entity.icon());
+        offsetx += entity.icon().bounds().width() + spacing_x;
+        drawn++;
+        if (drawn == icons_per_line) {
+            offsetx = spacing_x + 4;
+            offsety += spacing_y;
+        }
+    }
+}
+
+void HomeScreenView::new_fast_launch_entity(const LG::string& icon_path, LG::string&& exec_path)
+{
+    LG::PNG::PNGLoader loader;
+    m_fast_launch_entites.push_back(FastLaunchEntity());
+    m_fast_launch_entites.back().set_icon(loader.load_from_file(icon_path + "/48x48.png"));
+    m_fast_launch_entites.back().set_path_to_exec(std::move(exec_path));
+    set_needs_display();
+}
+
+void HomeScreenView::launch(const FastLaunchEntity& ent)
+{
+    if (fork() == 0) {
+        execve(ent.path_to_exec().c_str(), 0, 0);
+        std::abort();
+    }
+}
+
+void HomeScreenView::click_began(const LG::Point<int>& location)
+{
+    int spacing_x = (bounds().width() - 48 * icons_per_line) / 6;
+    int spacing_y = (bounds().height() - 48 * icons_per_column) / 7;
+    int offsetx = spacing_x + 4;
+    int offsety = spacing_y;
+    int drawn = 0;
+    for (auto& entity : m_fast_launch_entites) {
+        auto it = LG::Rect(offsetx, offsety, 48, 48);
+        if (it.contains(location)) {
+            launch(entity);
+        }
+        offsetx += entity.icon().bounds().width() + spacing_x;
+        drawn++;
+        if (drawn == icons_per_line) {
+            offsetx = spacing_x + 4;
+            offsety += spacing_y;
+        }
+    }
+}

userland/homescreen/HomeScreenView.h

···
+#pragma once
+#include "FastLaunchEntity.h"
+#include "HomeScreenEntity.h"
+#include <libg/Font.h>
+#include <libui/View.h>
+#include <list>
+#include <string>
+
+class HomeScreenView : public UI::View {
+    UI_OBJECT();
+
+public:
+    HomeScreenView(View* superview, const LG::Rect& frame);
+
+    void display(const LG::Rect& rect) override;
+    void click_began(const LG::Point<int>& location) override;
+
+    void new_fast_launch_entity(const LG::string& icon_path, LG::string&& exec_path);
+
+private:
+    void launch(const FastLaunchEntity& ent);
+
+    std::list<FastLaunchEntity> m_fast_launch_entites {};
+};

userland/homescreen/HomeScreenViewController.h

···
+/*
+ * Copyright (C) 2020-2021 Nikita Melekhin. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include "HomeScreenView.h"
+#include <libui/App.h>
+#include <libui/Button.h>
+#include <libui/Label.h>
+#include <libui/View.h>
+#include <libui/ViewController.h>
+#include <libui/Window.h>
+#include <memory>
+#include <sys/types.h>
+
+class HomeScreenViewController : public UI::ViewController<HomeScreenView> {
+public:
+    HomeScreenViewController(HomeScreenView& view)
+        : UI::ViewController<HomeScreenView>(view)
+    {
+    }
+    virtual ~HomeScreenViewController() = default;
+
+    virtual void view_did_load() override
+    {
+        view().set_background_color(LG::Color(222, 222, 222, 180));
+        view().new_fast_launch_entity("/res/icons/apps/about.icon", "/bin/about"); // FIXME: Parse some init file
+        view().new_fast_launch_entity("/res/icons/apps/terminal.icon", "/bin/terminal");
+        view().new_fast_launch_entity("/res/icons/apps/activity_monitor.icon", "/bin/activity_monitor");
+        view().set_needs_display();
+    }
+
+private:
+};

userland/homescreen/HomeScreenWindow.h

···
+#pragma once
+
+#include <libg/Size.h>
+#include <libui/Window.h>
+
+class HomeScreenWindow : public UI::Window {
+public:
+    HomeScreenWindow(const LG::Size& size)
+        : UI::Window(size, UI::WindowType::Homescreen)
+    {
+    }
+};