[userland][system] Init of AppList

build/userland/BUILD.gn

···
     "//userland/applications/calculator:calculator",
     "//userland/applications/terminal:terminal",
     "//userland/shell/onesh:onesh",
+    "//userland/system/applist:applist",
     "//userland/system/dock:dock",
     "//userland/system/homescreen:homescreen",
     "//userland/system/init:init",

build/userland/TEMPLATE.gni

···
                              "asmflags",
                              "ldflags",
                              "public_deps",
+                             "include_dirs",
                            ])
   }
 
···
                              "asmflags",
                              "ldflags",
                              "public_deps",
+                             "include_dirs",
                            ])
   }
 

userland/system/applist/AppDelegate.cpp

···
+#include "AppListView.h"
+#include "AppListViewController.h"
+#include "AppListWindow.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::opuntiaos::construct<AppListWindow>();
+        window.set_bitmap_format(LG::PixelBitmapFormat::RGBA);
+        auto& dock_view = window.create_superview<AppListView, AppListViewController>();
+        return true;
+    }
+
+private:
+};
+
+SET_APP_DELEGATE(AppDelegate);

userland/system/applist/AppListView.cpp

···
+#include "AppListView.h"
+#include "IconView.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 AppListView* this_view;
+
+AppListView::AppListView(UI::View* superview, const LG::Rect& frame)
+    : UI::View(superview, frame)
+{
+    auto& dock_stack_view = add_subview<UI::StackView>(bounds());
+    dock_stack_view.set_spacing(padding());
+    dock_stack_view.set_background_color(LG::Color::Opaque);
+    dock_stack_view.set_axis(UI::LayoutConstraints::Axis::Horizontal);
+    dock_stack_view.set_distribution(UI::StackView::Distribution::EqualCentering);
+    m_dock_stackview = &dock_stack_view;
+}
+
+AppListView::AppListView(UI::View* superview, UI::Window* window, const LG::Rect& frame)
+    : UI::View(superview, window, frame)
+{
+    auto& label = add_subview<UI::Label>(LG::Rect(16, 16, 16, 24));
+    label.set_text_color(LG::Color::DarkSystemText);
+    label.set_text("App List");
+    label.set_font(LG::Font::system_font(LG::Font::SystemTitleSize));
+    label.set_width(label.preferred_width());
+
+    auto& dock_stack_view = add_subview<UI::StackView>(LG::Rect(0, 50, bounds().width(), bounds().height()));
+    dock_stack_view.set_spacing(padding());
+    dock_stack_view.set_background_color(LG::Color::Opaque);
+    dock_stack_view.set_axis(UI::LayoutConstraints::Axis::Horizontal);
+    dock_stack_view.set_distribution(UI::StackView::Distribution::EqualCentering);
+    m_dock_stackview = &dock_stack_view;
+}
+
+void AppListView::display(const LG::Rect& rect)
+{
+    LG::Context ctx = UI::graphics_current_context();
+    ctx.add_clip(rect);
+
+    ctx.set_fill_color(background_color());
+    ctx.fill_rounded(bounds(), layer().corner_mask());
+}
+
+void AppListView::new_dock_entity(const std::string& exec_path, const std::string& icon_path, const std::string& bundle_id)
+{
+    LG::PNG::PNGLoader loader;
+
+    auto& icon_view = m_dock_stackview->add_arranged_subview<IconView>();
+    icon_view.add_constraint(UI::Constraint(icon_view, UI::Constraint::Attribute::Height, UI::Constraint::Relation::Equal, icon_view_size()));
+    icon_view.add_constraint(UI::Constraint(icon_view, UI::Constraint::Attribute::Width, UI::Constraint::Relation::Equal, icon_view_size()));
+    icon_view.entity().set_icon(loader.load_from_file(icon_path + "/48x48.png"));
+    icon_view.entity().set_path_to_exec(std::move(exec_path));
+    icon_view.entity().set_bundle_id(std::move(bundle_id));
+    m_icon_views.push_back(&icon_view);
+    set_needs_layout();
+}

userland/system/applist/AppListView.h

···
+#pragma once
+#include "DockEntity.h"
+#include "IconView.h"
+#include "WindowEntity.h"
+#include <libg/Font.h>
+#include <libui/StackView.h>
+#include <libui/View.h>
+#include <list>
+#include <string>
+
+class AppListView : public UI::View {
+    UI_OBJECT();
+
+public:
+    AppListView(UI::View* superview, const LG::Rect& frame);
+    AppListView(UI::View* superview, UI::Window* window, const LG::Rect& frame);
+
+    static constexpr size_t padding() { return 0; }
+    static constexpr size_t dock_view_height() { return 46; }
+    static constexpr int icon_size() { return 48; }
+    static constexpr int icon_view_size() { return (int)60; }
+
+    void display(const LG::Rect& rect) override;
+
+    void new_dock_entity(const std::string& exec_path, const std::string& icon_path, const std::string& bundle_id);
+
+private:
+    void launch(const DockEntity& ent);
+
+    UI::StackView* m_dock_stackview {};
+    std::list<IconView*> m_icon_views {};
+};

userland/system/applist/AppListViewController.h

···
+/*
+ * Copyright (C) 2020-2021 The opuntiaOS Project Authors.
+ *  + Contributed by Nikita Melekhin <[e-mail]>
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+#include "AppListView.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 AppListViewController : public UI::ViewController<AppListView> {
+public:
+    AppListViewController(AppListView& view)
+        : UI::ViewController<AppListView>(view)
+    {
+    }
+    virtual ~AppListViewController() = default;
+
+    virtual void view_did_load() override
+    {
+        view().set_background_color(LG::Color::LightSystemWhiteOpaque);
+        view().layer().set_corner_mask(LG::CornerMask(4, LG::CornerMask::Masked, LG::CornerMask::NonMasked));
+        view().new_dock_entity("/Applications/about.app/Content/about", "/res/icons/apps/about.icon", "com.opuntia.about");
+        view().new_dock_entity("/Applications/terminal.app/Content/terminal", "/res/icons/apps/terminal.icon", "com.opuntia.terminal");
+        view().new_dock_entity("/Applications/activity_monitor.app/Content/activity_monitor", "/res/icons/apps/activity_monitor.icon", "com.opuntia.activity_monitor");
+        view().new_dock_entity("/Applications/calculator.app/Content/calculator", "/res/icons/apps/calculator.icon", "com.opuntia.calculator");
+        view().set_needs_display();
+    }
+
+private:
+};

userland/system/applist/AppListWindow.cpp

···
+#include "AppListWindow.h"
+#include "AppListView.h"
+
+void AppListWindow::receive_event(std::unique_ptr<LFoundation::Event> event)
+{
+    Window::receive_event(std::move(event));
+}

userland/system/applist/AppListWindow.h

···
+#pragma once
+
+#include <libg/Size.h>
+#include <libui/Screen.h>
+#include <libui/Window.h>
+
+class AppListWindow : public UI::Window {
+public:
+    AppListWindow()
+        : UI::Window("AppList", LG::Size(320, 400), UI::WindowType::AppList)
+    {
+    }
+
+    void receive_event(std::unique_ptr<LFoundation::Event> event) override;
+};

userland/system/applist/BUILD.gn

···
+import("//build/userland/TEMPLATE.gni")
+
+opuntiaOS_executable("applist") {
+  install_path = "System/"
+  sources = [
+    "AppDelegate.cpp",
+    "AppListView.cpp",
+    "AppListWindow.cpp",
+    "IconView.cpp",
+  ]
+  configs = [ "//build/userland:userland_flags" ]
+  deplibs = [
+    "libcxx",
+    "libfoundation",
+    "libg",
+    "libui",
+  ]
+}

userland/system/applist/DockEntity.h

···
+#pragma once
+#include "WindowEntity.h"
+#include <libg/PixelBitmap.h>
+#include <list>
+#include <string>
+
+class DockEntity {
+public:
+    DockEntity() = 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(const std::string& path) { m_path_to_exec = path; }
+    const std::string& path_to_exec() const { return m_path_to_exec; }
+
+    void set_bundle_id(const std::string& bid) { m_bundle_id = bid; }
+    const std::string& bundle_id() const { return m_bundle_id; }
+
+    void add_window(const WindowEntity& went) { m_windows.push_front(went); }
+    const std::list<WindowEntity>& windows() const { return m_windows; }
+    std::list<WindowEntity>& windows() { return m_windows; }
+
+private:
+    LG::PixelBitmap m_icon;
+    std::string m_path_to_exec {};
+    std::string m_bundle_id {};
+    std::list<WindowEntity> m_windows {};
+};

userland/system/applist/IconView.cpp

···
+#include "IconView.h"
+#include "AppListView.h"
+#include <libui/App.h>
+#include <libui/Context.h>
+#include <libui/Label.h>
+#include <libui/Screen.h>
+#include <libui/Window.h>
+
+IconView::IconView(View* superview, const LG::Rect& frame)
+    : View(superview, frame)
+{
+}
+
+void IconView::display(const LG::Rect& rect)
+{
+    const int padding = 4;
+    const int offset_x = (AppListView::icon_view_size() - AppListView::icon_size()) / 2;
+    const int offset_y = (AppListView::icon_view_size() - AppListView::icon_size()) / 2;
+    LG::Context ctx = UI::graphics_current_context();
+    ctx.add_clip(rect);
+
+    if (is_hovered()) {
+        auto rect = LG::Rect(padding, padding, AppListView::icon_view_size() - 2 * padding, AppListView::icon_view_size() - 2 * padding);
+        ctx.set_fill_color(LG::Color::White);
+        ctx.fill_rounded(rect, LG::CornerMask(6));
+        ctx.set_fill_color(LG::Color(120, 129, 133, 60));
+        ctx.draw_box_shading(rect, LG::Shading(LG::Shading::Type::Box, 0, 2), LG::CornerMask(6));
+    }
+
+    ctx.draw({ offset_x, offset_y }, m_launch_entity.icon());
+
+    ctx.set_fill_color(LG::Color(120, 129, 133));
+    const int underline_y = AppListView::icon_view_size() - underline_height() - padding;
+    if (entity().windows().size() > 1) {
+        const int len = 10;
+        ctx.fill({ (AppListView::icon_view_size() - len) / 2, underline_y, len - underline_height(), underline_height() });
+        ctx.fill({ (AppListView::icon_view_size() - len) / 2 + len, underline_y, underline_height(), underline_height() });
+    } else if (entity().windows().size() > 0) {
+        const int len = 10;
+        ctx.fill({ (AppListView::icon_view_size() - len) / 2, underline_y, len, underline_height() });
+    }
+}
+
+void IconView::on_click()
+{
+    if (entity().windows().size() == 0) {
+        launch();
+        return;
+    } else {
+        auto demo_menu = UI::Menu();
+        for (auto& win : entity().windows()) {
+            auto title = win.title();
+            int this_window_id = window()->id();
+            int target_window_id = win.window_id();
+
+            if (win.is_minimized()) {
+                title += " - minimized";
+            }
+
+            demo_menu.add_item(UI::MenuItem(title, [this, this_window_id, target_window_id] {
+                auto& app = UI::App::the();
+                AskBringToFrontMessage msg(app.connection().key(), this_window_id, target_window_id);
+                // this->entity().set_minimized(false);
+                app.connection().send_async_message(msg);
+            }));
+        }
+        demo_menu.add_item(UI::MenuItem("New window", [this] {
+            launch();
+        }));
+        window()->popup_manager().show({ frame().min_x(), (int)UI::Screen::main().bounds().height() - (int)AppListView::dock_view_height() - 4 }, demo_menu);
+    }
+}

userland/system/applist/IconView.h

···
+#pragma once
+#include "DockEntity.h"
+#include "WindowEntity.h"
+#include <libg/Font.h>
+#include <libui/Label.h>
+#include <libui/PopupMenu.h>
+#include <libui/View.h>
+#include <list>
+#include <string>
+#include <unistd.h>
+
+class IconView : public UI::View {
+    UI_OBJECT();
+
+public:
+    IconView(View* superview, const LG::Rect& frame);
+
+    void display(const LG::Rect& rect) override;
+    void mouse_down(const LG::Point<int>& location) override { on_click(); }
+
+    static constexpr size_t underline_height() { return 3; }
+
+    void set_title(const std::string& title)
+    {
+        if (!m_label) {
+            return;
+        }
+        m_label->set_text(title);
+    }
+
+    DockEntity& entity() { return m_launch_entity; }
+    const DockEntity& entity() const { return m_launch_entity; }
+
+private:
+    void on_click();
+    void launch()
+    {
+        if (fork() == 0) {
+            execve(m_launch_entity.path_to_exec().c_str(), 0, 0);
+            std::abort();
+        }
+    }
+
+    UI::Label* m_label;
+    DockEntity m_launch_entity;
+};

userland/system/applist/WindowEntity.h

···
+#pragma once
+#include <libg/PixelBitmap.h>
+#include <string>
+
+class WindowEntity {
+public:
+    enum Status : uint32_t {
+        Minimized = (1 << 0),
+    };
+
+    WindowEntity()
+        : m_window_id(0)
+        , m_title()
+    {
+    }
+
+    WindowEntity(int window_id)
+        : m_window_id(window_id)
+        , m_title()
+    {
+    }
+
+    bool operator==(const WindowEntity& other) const { return m_window_id == other.m_window_id; }
+    bool operator!=(const WindowEntity& other) const { return m_window_id != other.m_window_id; }
+
+    int window_id() const { return m_window_id; }
+
+    bool is_minimized() const { return has_attr(Status::Minimized); }
+    void set_minimized(bool b) { b ? set_attr(Status::Minimized) : rem_attr(Status::Minimized); }
+
+    const std::string& title() const { return m_title; }
+    void set_title(const std::string& title) { m_title = title; }
+    void set_title(std::string&& title) { m_title = std::move(title); }
+
+private:
+    inline bool has_attr(Status mode) const { return ((m_window_status & (uint32_t)mode) == (uint32_t)mode); }
+    inline void set_attr(Status mode) { m_window_status |= (uint32_t)mode; }
+    inline void rem_attr(Status mode) { m_window_status = m_window_status & (~(uint32_t)mode); }
+
+    int m_window_id { 0 };
+    uint32_t m_window_status { 0 };
+    std::string m_title {};
+};

userland/system/dock/AppListView.cpp

···
     }
 
     ctx.draw({ offset_x, offset_y }, m_icon);
+}
+
+void AppListView::on_click()
+{
+    int this_window_id = window()->id();
+
+    if (m_target_window_id == INVALID) {
+        return;
+    }
+
+    auto& app = UI::App::the();
+    AskBringToFrontMessage msg(app.connection().key(), this_window_id, m_target_window_id);
+    // this->entity().set_minimized(false);
+    app.connection().send_async_message(msg);
 }

userland/system/dock/AppListView.h

···
 class AppListView : public UI::View {
     UI_OBJECT();
 
+    static constexpr int INVALID = -1;
+
 public:
     AppListView(View* superview, const LG::Rect& frame);
 
+    void set_target_window_id(int winid) { m_target_window_id = winid; }
+
     void display(const LG::Rect& rect) override;
-    void mouse_down(const LG::Point<int>& location) override { }
+    void mouse_down(const LG::Point<int>& location) override { on_click(); }
 
 private:
+    void on_click();
+
+    int m_target_window_id { INVALID };
     LG::PixelBitmap m_icon;
 };

userland/system/dock/DockView.cpp

···
     auto& icon_view = m_dock_stackview->add_arranged_subview<AppListView>();
     icon_view.add_constraint(UI::Constraint(icon_view, UI::Constraint::Attribute::Height, UI::Constraint::Relation::Equal, icon_view_size()));
     icon_view.add_constraint(UI::Constraint(icon_view, UI::Constraint::Attribute::Width, UI::Constraint::Relation::Equal, icon_view_size()));
+    m_applist_view = &icon_view;
 }
 
 void DockView::display(const LG::Rect& rect)
···
     return nullptr;
 }
 
-void DockView::on_window_create(const std::string& bundle_id, const std::string& icon_path, int window_id)
+void DockView::on_window_create(const std::string& bundle_id, const std::string& icon_path, int window_id, int window_type)
 {
     // Don't add an icon of dock (self).
     if (window()->id() == window_id) {
+        return;
+    }
+
+    if (window_type == WindowType::AppList) {
+        if (m_applist_view) {
+            m_applist_view->set_target_window_id(window_id);
+        }
         return;
     }
 

userland/system/dock/DockView.h

···
 #pragma once
+#include "AppListView.h"
 #include "DockEntity.h"
 #include "IconView.h"
 #include "WindowEntity.h"
···
     void display(const LG::Rect& rect) override;
 
     WindowEntity* find_window_entry(int window_id);
-    void on_window_create(const std::string& bundle_id, const std::string& icon_path, int window_id);
+    void on_window_create(const std::string& bundle_id, const std::string& icon_path, int window_id, int window_type);
     void on_window_remove(int window_id);
     void on_window_minimize(int window_id);
     void set_icon(int window_id, const std::string& path);
···
     void launch(const DockEntity& ent);
 
     UI::StackView* m_dock_stackview {};
+    AppListView* m_applist_view {};
     std::list<IconView*> m_icon_views {};
 };

userland/system/dock/DockWindow.cpp

···
     if (event->type() == UI::Event::Type::NotifyWindowCreateEvent) {
         UI::NotifyWindowCreateEvent& own_event = *(UI::NotifyWindowCreateEvent*)event.get();
         DockView* it = (DockView*)superview();
-        it->on_window_create(own_event.bundle_id(), own_event.icon_path(), own_event.window_id());
+        it->on_window_create(own_event.bundle_id(), own_event.icon_path(), own_event.window_id(), own_event.window_type());
     }
     if (event->type() == UI::Event::Type::NotifyWindowStatusChangedEvent) {
         UI::NotifyWindowStatusChangedEvent& own_event = *(UI::NotifyWindowStatusChangedEvent*)event.get();

userland/system/dock/DockWindow.h

···
     DockWindow()
         : UI::Window("Dock", LG::Size(UI::Screen::main().bounds().width(), 46), UI::WindowType::Homescreen)
     {
+        if (fork() == 0) {
+            execve("/System/applist", 0, 0);
+            std::abort();
+        }
     }
 
     void receive_event(std::unique_ptr<LFoundation::Event> event) override;