apps/2048.cpp

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

apps/about.cpp

@@ -42,5 +42,7 @@ 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,7 +48,6 @@ 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);
@@ -66,5 +65,7 @@ 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,57 +12,24 @@
 
 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;
@@ -70,12 +37,9 @@ namespace os
             return *this;
         }
 
-        /**
-         * @brief Call the underlying object.
-         */
         void operator()()
         {
-            expect(m_action, "os::Action called with no underlying callable object");
+            check(m_action);
             return m_action->call();
         }
 

libui/src/App.cpp

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