apps+libui: Make app.run() call window->draw() automatically

apps/2048.cpp

@@ -360,7 +360,5 @@ Result<int> luna_main(int argc, char** argv)
     window->set_main_widget(game);
     game.reset();
 
-    window->draw();
-
     return app.run();
 }

apps/about.cpp

@@ -42,7 +42,5 @@ Result<int> luna_main(int argc, char** argv)
     ui::Label kernel_version(kernel_version_text.view());
     version_info.add_widget(kernel_version);
 
-    window->draw();
-
     return app.run();
 }

apps/taskbar.cpp

@@ -48,6 +48,7 @@ Result<int> luna_main(int argc, char** argv)
 
     auto window = TRY(ui::Window::create(bar, ui::WindowType::System));
     app.set_main_window(window);
+
     window->set_background(TASKBAR_COLOR);
 
     ui::HorizontalLayout layout(ui::Margins { 0, 0, 0, 0 }, ui::AdjustHeight::Yes, ui::AdjustWidth::No);
@@ -65,7 +66,5 @@ Result<int> luna_main(int argc, char** argv)
     StringView clock_command[] = { "/usr/bin/clock" };
     TRY(create_widget_group_for_app(layout, { clock_command, 1 }, "/usr/share/icons/32x32/app-clock.tga"));
 
-    window->draw();
-
     return app.run();
 }

libos/include/os/Action.h

@@ -12,24 +12,57 @@
 
 namespace os
 {
+    /**
+     * @brief Wrapper for callable objects.
+     *
+     * Certain callable types such as capture lambdas don't have a named type, thus they can't be passed to functions as
+     * arguments. The Action type acts as a callable wrapper for such functions, allowing them to be passed as arguments
+     * to any function.
+     */
     class Action
     {
       public:
+        /**
+         * @brief Construct a new empty Action object.
+         *
+         * Since it is not wrapping any callable object, this object is invalid and attempting to invoke its
+         * (nonexistent) callable object will result in a crash at runtime.
+         */
         Action()
         {
             m_action = nullptr;
         }
 
+        /**
+         * @brief Construct a new Action object, moving it from another one.
+         *
+         * @param other The old Action object to move from. This object will become invalid.
+         */
         Action(Action&& other) : m_action(other.m_action)
         {
             other.m_action = nullptr;
         }
 
+        /**
+         * @brief Construct a new Action object from a callable object.
+         *
+         * @tparam T The type of the callable object. Since this can be guessed by template deduction, the object
+         * doesn't actually need a type name.
+         * @param function The callable object to wrap.
+         */
         template <typename T> Action(T&& function)
         {
             m_action = new (std::nothrow) ActionImpl<T>(move(function));
         }
 
+        /**
+         * @brief Assign a new callable object to this Action.
+         *
+         * @tparam T The type of the callable object. Since this can be guessed by template deduction, the object
+         * doesn't actually need a type name.
+         * @param function The callable object to wrap.
+         * @return Action& A reference to this object, as required by operator=().
+         */
         template <typename T> Action& operator=(T&& function)
         {
             if (m_action) delete m_action;
@@ -37,9 +70,12 @@ namespace os
             return *this;
         }
 
+        /**
+         * @brief Call the underlying object.
+         */
         void operator()()
         {
-            check(m_action);
+            expect(m_action, "os::Action called with no underlying callable object");
             return m_action->call();
         }
 

libui/src/App.cpp

@@ -59,6 +59,8 @@ namespace ui
 
     Result<int> App::run()
     {
+        TRY(m_main_window->draw());
+
         return m_loop.run();
     }