SystemMonitor: Make all tabs except the process table lazily loaded

We now use GLazyWidget for all the secondary tabs, which makes the
program start up way faster than before.

There's a noticeable delay when you click on the "PCI Devices" tab
for the first time, but that's definitely better than always eating
that delay before seeing a window at all. :^)

Applications/SystemMonitor/MemoryStatsWidget.cpp

@@ -1,18 +1,28 @@
 #include "MemoryStatsWidget.h"
 #include "GraphWidget.h"
 #include <AK/JsonObject.h>
+#include <LibDraw/StylePainter.h>
 #include <LibGUI/GBoxLayout.h>
 #include <LibGUI/GLabel.h>
 #include <LibGUI/GPainter.h>
-#include <LibDraw/StylePainter.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+static MemoryStatsWidget* s_the;
+
+MemoryStatsWidget* MemoryStatsWidget::the()
+{
+    return s_the;
+}
+
 MemoryStatsWidget::MemoryStatsWidget(GraphWidget& graph, GWidget* parent)
     : GWidget(parent)
     , m_graph(graph)
     , m_proc_memstat(CFile::construct("/proc/memstat"))
 {
+    ASSERT(!s_the);
+    s_the = this;
+
     if (!m_proc_memstat->open(CIODevice::OpenMode::ReadOnly))
         ASSERT_NOT_REACHED();
     set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);

Applications/SystemMonitor/MemoryStatsWidget.h

@@ -9,12 +9,15 @@ class GraphWidget;
 class MemoryStatsWidget final : public GWidget {
     C_OBJECT(MemoryStatsWidget)
 public:
-    MemoryStatsWidget(GraphWidget& graph, GWidget* parent);
+    static MemoryStatsWidget* the();
+
     virtual ~MemoryStatsWidget() override;
 
     void refresh();
 
 private:
+    MemoryStatsWidget(GraphWidget& graph, GWidget* parent);
+
     virtual void timer_event(CTimerEvent&) override;
 
     GraphWidget& m_graph;

Applications/SystemMonitor/NetworkStatisticsWidget.cpp

@@ -5,8 +5,9 @@
 #include <LibGUI/GTableView.h>
 
 NetworkStatisticsWidget::NetworkStatisticsWidget(GWidget* parent)
-    : GWidget(parent)
+    : GLazyWidget(parent)
 {
+    on_first_show = [this](auto&) {
         set_layout(make<GBoxLayout>(Orientation::Vertical));
         layout()->set_margins({ 4, 4, 4, 4 });
         set_fill_with_background_color(true);
@@ -62,6 +63,7 @@ NetworkStatisticsWidget::NetworkStatisticsWidget(GWidget* parent)
             this);
 
         update_models();
+    };
 }
 
 NetworkStatisticsWidget::~NetworkStatisticsWidget()

Applications/SystemMonitor/NetworkStatisticsWidget.h

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <LibCore/CTimer.h>
-#include <LibGUI/GWidget.h>
+#include <LibGUI/GLazyWidget.h>
 
 class GTableView;
 
-class NetworkStatisticsWidget final : public GWidget {
+class NetworkStatisticsWidget final : public GLazyWidget {
     C_OBJECT(NetworkStatisticsWidget)
 public:
     virtual ~NetworkStatisticsWidget() override;

Applications/SystemMonitor/ProcessModel.cpp

@@ -8,9 +8,18 @@
 #include <fcntl.h>
 #include <stdio.h>
 
-ProcessModel::ProcessModel(GraphWidget& graph)
+static ProcessModel* s_the;
-    : m_graph(graph)
+
+ProcessModel& ProcessModel::the()
 {
+    ASSERT(s_the);
+    return *s_the;
+}
+
+ProcessModel::ProcessModel()
+{
+    ASSERT(!s_the);
+    s_the = this;
     m_generic_process_icon = GraphicsBitmap::load_from_file("/res/icons/gear16.png");
     m_high_priority_icon = GraphicsBitmap::load_from_file("/res/icons/highpriority16.png");
     m_low_priority_icon = GraphicsBitmap::load_from_file("/res/icons/lowpriority16.png");
@@ -263,7 +272,8 @@ void ProcessModel::update()
     for (auto pid : pids_to_remove)
         m_processes.remove(pid);
 
-    m_graph.add_value(total_cpu_percent);
+    if (on_new_cpu_data_point)
+        on_new_cpu_data_point(total_cpu_percent);
 
     did_update();
 }

Applications/SystemMonitor/ProcessModel.h

@@ -27,7 +27,9 @@ public:
         __Count
     };
 
-    static NonnullRefPtr<ProcessModel> create(GraphWidget& graph) { return adopt(*new ProcessModel(graph)); }
+    static ProcessModel& the();
+
+    static NonnullRefPtr<ProcessModel> create() { return adopt(*new ProcessModel); }
     virtual ~ProcessModel() override;
 
     virtual int row_count(const GModelIndex&) const override;
@@ -37,10 +39,10 @@ public:
     virtual GVariant data(const GModelIndex&, Role = Role::Display) const override;
     virtual void update() override;
 
-private:
+    Function<void(float)> on_new_cpu_data_point;
-    explicit ProcessModel(GraphWidget&);
 
-    GraphWidget& m_graph;
+private:
+    ProcessModel();
 
     struct ProcessState {
         pid_t pid;

Applications/SystemMonitor/ProcessTableView.cpp

@@ -3,11 +3,11 @@
 #include <LibGUI/GSortingProxyModel.h>
 #include <stdio.h>
 
-ProcessTableView::ProcessTableView(GraphWidget& graph, GWidget* parent)
+ProcessTableView::ProcessTableView(GWidget* parent)
     : GTableView(parent)
 {
     set_size_columns_to_fit_content(true);
-    set_model(GSortingProxyModel::create(ProcessModel::create(graph)));
+    set_model(GSortingProxyModel::create(ProcessModel::create()));
     model()->set_key_column_and_sort_order(ProcessModel::Column::CPU, GSortOrder::Descending);
     refresh();
 

Applications/SystemMonitor/ProcessTableView.h

@@ -19,5 +19,5 @@ public:
     Function<void(pid_t)> on_process_selected;
 
 private:
-    ProcessTableView(GraphWidget&, GWidget* parent);
+    explicit ProcessTableView(GWidget* parent = nullptr);
 };

Applications/SystemMonitor/main.cpp

@@ -4,6 +4,7 @@
 #include "NetworkStatisticsWidget.h"
 #include "ProcessFileDescriptorMapWidget.h"
 #include "ProcessMemoryMapWidget.h"
+#include "ProcessModel.h"
 #include "ProcessStacksWidget.h"
 #include "ProcessTableView.h"
 #include <LibCore/CTimer.h>
@@ -15,6 +16,7 @@
 #include <LibGUI/GGroupBox.h>
 #include <LibGUI/GJsonArrayModel.h>
 #include <LibGUI/GLabel.h>
+#include <LibGUI/GLazyWidget.h>
 #include <LibGUI/GMenuBar.h>
 #include <LibGUI/GPainter.h>
 #include <LibGUI/GSortingProxyModel.h>
@@ -42,6 +44,7 @@ static String human_readable_size(u32 size)
 static RefPtr<GWidget> build_file_systems_tab();
 static RefPtr<GWidget> build_pci_devices_tab();
 static RefPtr<GWidget> build_devices_tab();
+static NonnullRefPtr<GWidget> build_graphs_tab();
 
 int main(int argc, char** argv)
 {
@@ -60,38 +63,7 @@ int main(int argc, char** argv)
 
     auto process_table_container = GWidget::construct(process_container_splitter.ptr());
 
-    auto graphs_container = GWidget::construct();
+    tabwidget->add_widget("Graphs", build_graphs_tab());
-    graphs_container->set_fill_with_background_color(true);
-    graphs_container->set_background_color(Color::WarmGray);
-    graphs_container->set_layout(make<GBoxLayout>(Orientation::Vertical));
-    graphs_container->layout()->set_margins({ 4, 4, 4, 4 });
-
-    auto cpu_graph_group_box = GGroupBox::construct("CPU usage", graphs_container);
-    cpu_graph_group_box->set_layout(make<GBoxLayout>(Orientation::Vertical));
-    cpu_graph_group_box->layout()->set_margins({ 6, 16, 6, 6 });
-    cpu_graph_group_box->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
-    cpu_graph_group_box->set_preferred_size(0, 120);
-    auto cpu_graph = GraphWidget::construct(cpu_graph_group_box);
-    cpu_graph->set_max(100);
-    cpu_graph->set_text_color(Color::Green);
-    cpu_graph->set_graph_color(Color::from_rgb(0x00bb00));
-    cpu_graph->text_formatter = [](int value, int) {
-        return String::format("%d%%", value);
-    };
-
-    auto memory_graph_group_box = GGroupBox::construct("Memory usage", graphs_container);
-    memory_graph_group_box->set_layout(make<GBoxLayout>(Orientation::Vertical));
-    memory_graph_group_box->layout()->set_margins({ 6, 16, 6, 6 });
-    memory_graph_group_box->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
-    memory_graph_group_box->set_preferred_size(0, 120);
-    auto memory_graph = GraphWidget::construct(memory_graph_group_box);
-    memory_graph->set_text_color(Color::Cyan);
-    memory_graph->set_graph_color(Color::from_rgb(0x00bbbb));
-    memory_graph->text_formatter = [](int value, int max) {
-        return String::format("%d / %d KB", value, max);
-    };
-
-    tabwidget->add_widget("Graphs", graphs_container);
 
     tabwidget->add_widget("File systems", build_file_systems_tab());
 
@@ -108,11 +80,11 @@ int main(int argc, char** argv)
 
     auto toolbar = GToolBar::construct(process_table_container);
     toolbar->set_has_frame(false);
-    auto process_table_view = ProcessTableView::construct(*cpu_graph, process_table_container);
+    auto process_table_view = ProcessTableView::construct(process_table_container);
-    auto memory_stats_widget = MemoryStatsWidget::construct(*memory_graph, graphs_container);
 
     auto refresh_timer = CTimer::construct(1000, [&] {
         process_table_view->refresh();
+        if (auto* memory_stats_widget = MemoryStatsWidget::the())
             memory_stats_widget->refresh();
     });
 
@@ -236,10 +208,12 @@ public:
 
 RefPtr<GWidget> build_file_systems_tab()
 {
-    auto fs_widget = GWidget::construct();
+    auto fs_widget = GLazyWidget::construct();
-    fs_widget->set_layout(make<GBoxLayout>(Orientation::Vertical));
+
-    fs_widget->layout()->set_margins({ 4, 4, 4, 4 });
+    fs_widget->on_first_show = [](auto& self) {
-    auto fs_table_view = GTableView::construct(fs_widget);
+        self.set_layout(make<GBoxLayout>(Orientation::Vertical));
+        self.layout()->set_margins({ 4, 4, 4, 4 });
+        auto fs_table_view = GTableView::construct(&self);
         fs_table_view->set_size_columns_to_fit_content(true);
 
         Vector<GJsonArrayModel::FieldSpec> df_fields;
@@ -296,15 +270,18 @@ RefPtr<GWidget> build_file_systems_tab()
         fs_table_view->set_cell_painting_delegate(3, make<ProgressBarPaintingDelegate>());
 
         fs_table_view->model()->update();
+    };
     return fs_widget;
 }
 
 RefPtr<GWidget> build_pci_devices_tab()
 {
-    auto pci_widget = GWidget::construct();
+    auto pci_widget = GLazyWidget::construct();
-    pci_widget->set_layout(make<GBoxLayout>(Orientation::Vertical));
+
-    pci_widget->layout()->set_margins({ 4, 4, 4, 4 });
+    pci_widget->on_first_show = [](auto& self) {
-    auto pci_table_view = GTableView::construct(pci_widget);
+        self.set_layout(make<GBoxLayout>(Orientation::Vertical));
+        self.layout()->set_margins({ 4, 4, 4, 4 });
+        auto pci_table_view = GTableView::construct(&self);
         pci_table_view->set_size_columns_to_fit_content(true);
 
         auto db = PCIDB::Database::open();
@@ -349,20 +326,68 @@ RefPtr<GWidget> build_pci_devices_tab()
 
         pci_table_view->set_model(GSortingProxyModel::create(GJsonArrayModel::create("/proc/pci", move(pci_fields))));
         pci_table_view->model()->update();
+    };
 
     return pci_widget;
 }
 
 RefPtr<GWidget> build_devices_tab()
 {
-    auto devices_widget = GWidget::construct();
+    auto devices_widget = GLazyWidget::construct();
-    devices_widget->set_layout(make<GBoxLayout>(Orientation::Vertical));
-    devices_widget->layout()->set_margins({ 4, 4, 4, 4 });
 
-    auto devices_table_view = GTableView::construct(devices_widget);
+    devices_widget->on_first_show = [](auto& self) {
+        self.set_layout(make<GBoxLayout>(Orientation::Vertical));
+        self.layout()->set_margins({ 4, 4, 4, 4 });
+
+        auto devices_table_view = GTableView::construct(&self);
         devices_table_view->set_size_columns_to_fit_content(true);
         devices_table_view->set_model(GSortingProxyModel::create(DevicesModel::create()));
         devices_table_view->model()->update();
+    };
 
     return devices_widget;
 }
+
+NonnullRefPtr<GWidget> build_graphs_tab()
+{
+    auto graphs_container = GLazyWidget::construct();
+
+    graphs_container->on_first_show = [](auto& self) {
+        self.set_fill_with_background_color(true);
+        self.set_background_color(Color::WarmGray);
+        self.set_layout(make<GBoxLayout>(Orientation::Vertical));
+        self.layout()->set_margins({ 4, 4, 4, 4 });
+
+        auto cpu_graph_group_box = GGroupBox::construct("CPU usage", &self);
+        cpu_graph_group_box->set_layout(make<GBoxLayout>(Orientation::Vertical));
+        cpu_graph_group_box->layout()->set_margins({ 6, 16, 6, 6 });
+        cpu_graph_group_box->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
+        cpu_graph_group_box->set_preferred_size(0, 120);
+        auto cpu_graph = GraphWidget::construct(cpu_graph_group_box);
+        cpu_graph->set_max(100);
+        cpu_graph->set_text_color(Color::Green);
+        cpu_graph->set_graph_color(Color::from_rgb(0x00bb00));
+        cpu_graph->text_formatter = [](int value, int) {
+            return String::format("%d%%", value);
+        };
+
+        ProcessModel::the().on_new_cpu_data_point = [graph = cpu_graph.ptr()](float cpu_percent) {
+            graph->add_value(cpu_percent);
+        };
+
+        auto memory_graph_group_box = GGroupBox::construct("Memory usage", &self);
+        memory_graph_group_box->set_layout(make<GBoxLayout>(Orientation::Vertical));
+        memory_graph_group_box->layout()->set_margins({ 6, 16, 6, 6 });
+        memory_graph_group_box->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
+        memory_graph_group_box->set_preferred_size(0, 120);
+        auto memory_graph = GraphWidget::construct(memory_graph_group_box);
+        memory_graph->set_text_color(Color::Cyan);
+        memory_graph->set_graph_color(Color::from_rgb(0x00bbbb));
+        memory_graph->text_formatter = [](int value, int max) {
+            return String::format("%d / %d KB", value, max);
+        };
+
+        auto memory_stats_widget = MemoryStatsWidget::construct(*memory_graph, &self);
+    };
+    return graphs_container;
+}