source: mainline/uspace/app/shutdown-dlg/shutdown-dlg.c

/*
 * Copyright (c) 2025 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup shutdown-dlg
 * @{
 */
/** @file Shutdown dialog
 */

#include <gfx/coord.h>
#include <gfx/render.h>
#include <stdio.h>
#include <stdlib.h>
#include <str.h>
#include <system.h>
#include <ui/fixed.h>
#include <ui/label.h>
#include <ui/list.h>
#include <ui/msgdialog.h>
#include <ui/resource.h>
#include <ui/selectdialog.h>
#include <ui/ui.h>
#include <ui/window.h>
#include "shutdown-dlg.h"

static void wnd_close(ui_window_t *, void *);
static errno_t bg_wnd_paint(ui_window_t *, void *);
static void shutdown_progress_destroy(shutdown_progress_t *);
static errno_t shutdown_confirm_create(shutdown_dlg_t *);
static errno_t shutdown_failed_msg_create(shutdown_dlg_t *);
static errno_t shutdown_start(shutdown_dlg_t *, sd_action_t);

static ui_window_cb_t bg_window_cb = {
        .close = wnd_close,
        .paint = bg_wnd_paint
};

static ui_window_cb_t progress_window_cb = {
        .close = wnd_close
};

static void sd_shutdown_complete(void *);
static void sd_shutdown_failed(void *);

static system_cb_t sd_system_cb = {
        .shutdown_complete = sd_shutdown_complete,
        .shutdown_failed = sd_shutdown_failed
};

static void shutdown_confirm_bok(ui_select_dialog_t *, void *, void *);
static void shutdown_confirm_bcancel(ui_select_dialog_t *, void *);
static void shutdown_confirm_close(ui_select_dialog_t *, void *);

static ui_select_dialog_cb_t shutdown_confirm_cb = {
        .bok = shutdown_confirm_bok,
        .bcancel = shutdown_confirm_bcancel,
        .close = shutdown_confirm_close
};

static void shutdown_failed_msg_button(ui_msg_dialog_t *, void *, unsigned);
static void shutdown_failed_msg_close(ui_msg_dialog_t *, void *);

static ui_msg_dialog_cb_t shutdown_failed_msg_cb = {
        .button = shutdown_failed_msg_button,
        .close = shutdown_failed_msg_close
};

/** System shutdown complete.
 *
 * @param arg Argument (shutdown_dlg_t *)
 */
static void sd_shutdown_complete(void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *)arg;

        ui_lock(sddlg->ui);
        (void)ui_label_set_text(sddlg->progress->label,
            "Shutdown complete. It is now safe to remove power.");
        (void)ui_window_paint(sddlg->progress->window);
        ui_unlock(sddlg->ui);
}

/** System shutdown failed.
 *
 * @param arg Argument (shutdown_dlg_t *)
 */
static void sd_shutdown_failed(void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *)arg;

        ui_lock(sddlg->ui);
        shutdown_progress_destroy(sddlg->progress);
        sddlg->progress = NULL;
        ui_window_destroy(sddlg->bgwindow);
        sddlg->bgwindow = NULL;
        (void)shutdown_failed_msg_create(sddlg);
        ui_unlock(sddlg->ui);
}

/** Window close button was clicked.
 *
 * @param window Window
 * @param arg Argument (shutdown_dlg_t *)
 */
static void wnd_close(ui_window_t *window, void *arg)
{
        (void)window;
        (void)arg;
}

/** Paint background window.
 *
 * @param window Window
 * @param arg Argument (shutdown_dlg_t *)
 */
static errno_t bg_wnd_paint(ui_window_t *window, void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *)arg;
        gfx_rect_t app_rect;
        gfx_context_t *gc;
        errno_t rc;

        gc = ui_window_get_gc(window);

        rc = gfx_set_color(gc, sddlg->bg_color);
        if (rc != EOK)
                return rc;

        ui_window_get_app_rect(window, &app_rect);

        rc = gfx_fill_rect(gc, &app_rect);
        if (rc != EOK)
                return rc;

        rc = gfx_update(gc);
        if (rc != EOK)
                return rc;

        return EOK;
}

/** Create shutdown confirmation dialog.
 *
 * @param sddlg Shutdown dialog
 * @return EOK on success or an error code
 */
static errno_t shutdown_confirm_create(shutdown_dlg_t *sddlg)
{
        ui_select_dialog_params_t params;
        ui_select_dialog_t *dialog;
        ui_list_entry_attr_t attr;
        errno_t rc;

        ui_select_dialog_params_init(&params);
        params.caption = "Shutdown";
        params.prompt = "Do you want to shut the system down?";
        params.flags |= usdf_topmost | usdf_center;

        rc = ui_select_dialog_create(sddlg->ui, &params, &dialog);
        if (rc != EOK)
                return rc;

        /* Need an entry to select */
        ui_list_entry_attr_init(&attr);

        attr.caption = "Power off";
        attr.arg = (void *)sd_poweroff;
        rc = ui_select_dialog_append(dialog, &attr);
        if (rc != EOK)
                goto error;

        attr.caption = "Restart";
        attr.arg = (void *)sd_restart;
        rc = ui_select_dialog_append(dialog, &attr);
        if (rc != EOK)
                goto error;

        ui_select_dialog_set_cb(dialog, &shutdown_confirm_cb, sddlg);

        (void)ui_select_dialog_paint(dialog);

        return EOK;
error:
        ui_select_dialog_destroy(dialog);
        return rc;
}

/** Create 'shutdown failed' message dialog.
 *
 * @param sddlg Shutdown dialog
 * @return EOK on success or an error code
 */
static errno_t shutdown_failed_msg_create(shutdown_dlg_t *sddlg)
{
        ui_msg_dialog_params_t params;
        ui_msg_dialog_t *dialog;
        errno_t rc;

        ui_msg_dialog_params_init(&params);
        params.caption = "Shutdown failed";
        params.text = "The system failed to shut down properly.";

        rc = ui_msg_dialog_create(sddlg->ui, &params, &dialog);
        if (rc != EOK)
                return rc;

        ui_msg_dialog_set_cb(dialog, &shutdown_failed_msg_cb, sddlg);

        return EOK;
}

/** Shutdown confirm dialog OK button press.
 *
 * @param dialog Message dialog
 * @param arg Argument (shutdown_dlg_t *)
 * @param earg Entry argument
 */
static void shutdown_confirm_bok(ui_select_dialog_t *dialog, void *arg,
    void *earg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;

        ui_select_dialog_destroy(dialog);

        shutdown_start(sddlg, (sd_action_t)earg);
}

/** Shutdown confirm dialog Cancel button press.
 *
 * @param dialog Message dialog
 * @param arg Argument (shutdown_dlg_t *)
 */
static void shutdown_confirm_bcancel(ui_select_dialog_t *dialog, void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;

        ui_select_dialog_destroy(dialog);
        ui_quit(sddlg->ui);
}

/** Shutdown confirm message dialog close request.
 *
 * @param dialog Message dialog
 * @param arg Argument (shutdown_dlg_t *)
 */
static void shutdown_confirm_close(ui_select_dialog_t *dialog, void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;

        ui_select_dialog_destroy(dialog);
        ui_quit(sddlg->ui);
}

/** Shutdown faield message dialog button press.
 *
 * @param dialog Message dialog
 * @param arg Argument (shutdown_dlg_t *)
 * @param bnum Button number
 */
static void shutdown_failed_msg_button(ui_msg_dialog_t *dialog,
    void *arg, unsigned bnum)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;

        ui_msg_dialog_destroy(dialog);
        ui_quit(sddlg->ui);
}

/** Shutdown failed message dialog close request.
 *
 * @param dialog Message dialog
 * @param arg Argument (shutdown_dlg_t *)
 */
static void shutdown_failed_msg_close(ui_msg_dialog_t *dialog, void *arg)
{
        shutdown_dlg_t *sddlg = (shutdown_dlg_t *) arg;

        ui_msg_dialog_destroy(dialog);
        ui_quit(sddlg->ui);
}

/** Create shutdown progress window.
 *
 * @param sddlg Shutdown dialog
 * @param rprogress Place to store pointer to new progress window
 * @return EOK on success or an error code
 */
static errno_t shutdown_progress_create(shutdown_dlg_t *sddlg,
    shutdown_progress_t **rprogress)
{
        ui_wnd_params_t params;
        ui_window_t *window = NULL;
        gfx_rect_t rect;
        ui_resource_t *ui_res;
        shutdown_progress_t *progress;
        ui_fixed_t *fixed = NULL;
        errno_t rc;

        ui_wnd_params_init(&params);
        params.caption = "Shut down";
        params.style &= ~ui_wds_titlebar;
        params.flags |= ui_wndf_topmost;
        params.placement = ui_wnd_place_center;
        if (ui_is_textmode(sddlg->ui)) {
                params.rect.p0.x = 0;
                params.rect.p0.y = 0;
                params.rect.p1.x = 64;
                params.rect.p1.y = 5;
        } else {
                params.rect.p0.x = 0;
                params.rect.p0.y = 0;
                params.rect.p1.x = 450;
                params.rect.p1.y = 60;
        }

        progress = calloc(1, sizeof(shutdown_progress_t));
        if (progress == NULL) {
                rc = ENOMEM;
                printf("Out of memory.\n");
                goto error;
        }

        rc = ui_window_create(sddlg->ui, &params, &window);
        if (rc != EOK) {
                printf("Error creating window.\n");
                goto error;
        }

        ui_window_set_cb(window, &progress_window_cb, (void *) &sddlg);

        ui_res = ui_window_get_res(window);

        rc = ui_fixed_create(&fixed);
        if (rc != EOK) {
                printf("Error creating fixed layout.\n");
                goto error;
        }

        rc = ui_label_create(ui_res, "The system is shutting down...",
            &progress->label);
        if (rc != EOK) {
                printf("Error creating label.\n");
                goto error;
        }

        ui_window_get_app_rect(window, &rect);
        ui_label_set_rect(progress->label, &rect);
        ui_label_set_halign(progress->label, gfx_halign_center);
        ui_label_set_valign(progress->label, gfx_valign_center);

        rc = ui_fixed_add(fixed, ui_label_ctl(progress->label));
        if (rc != EOK) {
                printf("Error adding control to layout.\n");
                ui_label_destroy(progress->label);
                progress->label = NULL;
                goto error;
        }

        ui_window_add(window, ui_fixed_ctl(fixed));
        fixed = NULL;

        rc = ui_window_paint(window);
        if (rc != EOK) {
                printf("Error painting window.\n");
                goto error;
        }

        progress->window = window;
        progress->fixed = fixed;
        *rprogress = progress;
        return EOK;
error:
        if (progress != NULL && progress->fixed != NULL)
                ui_fixed_destroy(progress->fixed);
        if (window != NULL)
                ui_window_destroy(window);
        if (progress != NULL)
                free(progress);
        return rc;
}

/** Destroy shutdown progress window.
 *
 * @param sddlg Shutdown dialog
 * @param rprogress Place to store pointer to new progress window
 * @return EOK on success or an error code
 */
static void shutdown_progress_destroy(shutdown_progress_t *progress)
{
        if (progress == NULL)
                return;

        ui_window_destroy(progress->window);
        free(progress);
}

/** Start shutdown.
 *
 * @param sddlg Shutdown dialog
 * @param action Shutdown actin
 * @return EOK on success or an error code
 */
static errno_t shutdown_start(shutdown_dlg_t *sddlg, sd_action_t action)
{
        errno_t rc;

        rc = shutdown_progress_create(sddlg, &sddlg->progress);
        if (rc != EOK)
                return rc;

        rc = system_open(SYSTEM_DEFAULT, &sd_system_cb, sddlg, &sddlg->system);
        if (rc != EOK) {
                printf("Failed opening system control service.\n");
                goto error;
        }

        rc = EINVAL;

        switch (action) {
        case sd_poweroff:
                rc = system_poweroff(sddlg->system);
                break;
        case sd_restart:
                rc = system_restart(sddlg->system);
                break;
        }

        if (rc != EOK) {
                printf("Failed requesting system shutdown.\n");
                goto error;
        }

        return EOK;
error:
        return rc;
}

/** Run shutdown dialog on display. */
static errno_t shutdown_dlg(const char *display_spec)
{
        ui_t *ui = NULL;
        shutdown_dlg_t sddlg;
        ui_wnd_params_t params;
        errno_t rc;

        memset((void *) &sddlg, 0, sizeof(sddlg));

        rc = ui_create(display_spec, &ui);
        if (rc != EOK) {
                printf("Error creating UI on display %s.\n", display_spec);
                goto error;
        }

        sddlg.ui = ui;

        ui_wnd_params_init(&params);
        params.caption = "Shutdown";
        params.style &= ~ui_wds_decorated;
        params.placement = ui_wnd_place_full_screen;
        params.flags |= ui_wndf_topmost | ui_wndf_nofocus;

        rc = ui_window_create(sddlg.ui, &params, &sddlg.bgwindow);
        if (rc != EOK) {
                printf("Error creating window.\n");
                goto error;
        }

        ui_window_set_cb(sddlg.bgwindow, &bg_window_cb, (void *)&sddlg);

        if (ui_is_textmode(sddlg.ui)) {
                rc = gfx_color_new_ega(0x17, &sddlg.bg_color);
                if (rc != EOK) {
                        printf("Error allocating color.\n");
                        goto error;
                }
        } else {
                rc = gfx_color_new_rgb_i16(0x8000, 0xc800, 0xffff, &sddlg.bg_color);
                if (rc != EOK) {
                        printf("Error allocating color.\n");
                        goto error;
                }
        }

        rc = ui_window_paint(sddlg.bgwindow);
        if (rc != EOK) {
                printf("Error painting window.\n");
                goto error;
        }

        (void)shutdown_confirm_create(&sddlg);

        ui_run(ui);

        shutdown_progress_destroy(sddlg.progress);
        if (sddlg.bgwindow != NULL)
                ui_window_destroy(sddlg.bgwindow);
        if (sddlg.system != NULL)
                system_close(sddlg.system);
        gfx_color_delete(sddlg.bg_color);
        ui_destroy(ui);

        return EOK;
error:
        if (sddlg.system != NULL)
                system_close(sddlg.system);
        if (sddlg.bg_color != NULL)
                gfx_color_delete(sddlg.bg_color);
        if (sddlg.bgwindow != NULL)
                ui_window_destroy(sddlg.bgwindow);
        if (ui != NULL)
                ui_destroy(ui);
        return rc;
}

static void print_syntax(void)
{
        printf("Syntax: shutdown-dlg [-d <display-spec>]\n");
}

int main(int argc, char *argv[])
{
        const char *display_spec = UI_ANY_DEFAULT;
        errno_t rc;
        int i;

        i = 1;
        while (i < argc && argv[i][0] == '-') {
                if (str_cmp(argv[i], "-d") == 0) {
                        ++i;
                        if (i >= argc) {
                                printf("Argument missing.\n");
                                print_syntax();
                                return 1;
                        }

                        display_spec = argv[i++];
                } else {
                        printf("Invalid option '%s'.\n", argv[i]);
                        print_syntax();
                        return 1;
                }
        }

        if (i < argc) {
                print_syntax();
                return 1;
        }

        rc = shutdown_dlg(display_spec);
        if (rc != EOK)
                return 1;

        return 0;
}

/** @}
 */