source: mainline/uspace/app/taskbar/clock.c

/*
 * Copyright (c) 2022 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 taskbar
 * @{
 */
/** @file Taskbar clock.
 *
 * Displays the current time in an inset frame.
 */

#include <errno.h>
#include <gfx/render.h>
#include <gfx/text.h>
#include <stdlib.h>
#include <stdio.h>
#include <task.h>
#include <ui/control.h>
#include <ui/paint.h>
#include <ui/resource.h>
#include <ui/ui.h>
#include "clock.h"

static void taskbar_clock_ctl_destroy(void *);
static errno_t taskbar_clock_ctl_paint(void *);
static ui_evclaim_t taskbar_clock_ctl_kbd_event(void *, kbd_event_t *);
static ui_evclaim_t taskbar_clock_ctl_pos_event(void *, pos_event_t *);
static void taskbar_clock_timer(void *);

/** Taskbar clock control ops */
static ui_control_ops_t taskbar_clock_ctl_ops = {
        .destroy = taskbar_clock_ctl_destroy,
        .paint = taskbar_clock_ctl_paint,
        .kbd_event = taskbar_clock_ctl_kbd_event,
        .pos_event = taskbar_clock_ctl_pos_event
};

/** Create taskbar clock.
 *
 * @param window Containing window
 * @param rclock Place to store pointer to new clock
 * @return EOK on success or an error code
 */
errno_t taskbar_clock_create(ui_window_t *window, taskbar_clock_t **rclock)
{
        taskbar_clock_t *clock;
        errno_t rc;

        clock = calloc(1, sizeof(taskbar_clock_t));
        if (clock == NULL)
                return ENOMEM;

        rc = ui_control_new(&taskbar_clock_ctl_ops, (void *)clock,
            &clock->control);
        if (rc != EOK) {
                free(clock);
                return rc;
        }

        clock->timer = fibril_timer_create(NULL);
        if (clock->timer == NULL) {
                rc = ENOMEM;
                goto error;
        }

        fibril_mutex_initialize(&clock->lock);
        fibril_condvar_initialize(&clock->timer_done_cv);
        fibril_timer_set(clock->timer, 1000000, taskbar_clock_timer, clock);

        clock->window = window;
        *rclock = clock;
        return EOK;
error:
        ui_control_delete(clock->control);
        free(clock);
        return rc;
}

/** Destroy taskbar clock.
 *
 * @param clock Taskbar clock
 */
void taskbar_clock_destroy(taskbar_clock_t *clock)
{
        /*
         * Signal to the timer that we are cleaning up. If the timer handler
         * misses it and sets the timer again, we will clear that active
         * timer and be done (and if we were even slower and the timer
         * fired again, it's the same situation as before.
         */
        fibril_mutex_lock(&clock->lock);
        clock->timer_cleanup = true;
        fibril_mutex_unlock(&clock->lock);

        /* If we catch the timer while it's active, there's nothing to do. */
        if (fibril_timer_clear(clock->timer) != fts_active) {
                /* Need to wait for timer handler to finish */
                fibril_mutex_lock(&clock->lock);
                while (clock->timer_done == false)
                        fibril_condvar_wait(&clock->timer_done_cv, &clock->lock);
                fibril_mutex_unlock(&clock->lock);
        }

        fibril_timer_destroy(clock->timer);
        ui_control_delete(clock->control);
        free(clock);
}

static errno_t taskbar_clock_get_text(taskbar_clock_t *clock, char *buf,
    size_t bsize)
{
        struct timespec ts;
        struct tm tm;
        errno_t rc;

        getrealtime(&ts);
        rc = time_utc2tm(ts.tv_sec, &tm);
        if (rc != EOK)
                return rc;

        snprintf(buf, bsize, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
            tm.tm_sec);
        return EOK;
}

/** Paint taskbar clock.
 *
 * @param clock Taskbar clock
 */
errno_t taskbar_clock_paint(taskbar_clock_t *clock)
{
        gfx_context_t *gc = ui_window_get_gc(clock->window);
        ui_resource_t *res = ui_window_get_res(clock->window);
        ui_t *ui = ui_window_get_ui(clock->window);
        char buf[10];
        gfx_text_fmt_t fmt;
        gfx_coord2_t pos;
        gfx_rect_t irect;
        errno_t rc;

        if (!ui_is_textmode(ui)) {
                /* Paint frame */
                rc = ui_paint_inset_frame(res, &clock->rect, &irect);
                if (rc != EOK)
                        goto error;
        } else {
                irect = clock->rect;
        }

        rc = gfx_set_color(gc, ui_resource_get_wnd_face_color(res));
        if (rc != EOK)
                goto error;

        /* Fill background */
        rc = gfx_fill_rect(gc, &irect);
        if (rc != EOK)
                goto error;

        pos.x = (irect.p0.x + irect.p1.x) / 2;
        pos.y = (irect.p0.y + irect.p1.y) / 2;

        gfx_text_fmt_init(&fmt);
        fmt.font = ui_resource_get_font(res);
        fmt.color = ui_resource_get_wnd_text_color(res);
        fmt.halign = gfx_halign_center;
        fmt.valign = gfx_valign_center;

        rc = taskbar_clock_get_text(clock, buf, sizeof(buf));
        if (rc != EOK)
                goto error;

        rc = gfx_puttext(&pos, &fmt, buf);
        if (rc != EOK)
                goto error;

        rc = gfx_update(gc);
        if (rc != EOK)
                goto error;

        return EOK;
error:
        return rc;
}

/** Handle taskbar clock keyboard event.
 *
 * @param clock Taskbar clock
 * @param event Keyboard event
 * @return ui_claimed iff event was claimed
 */
ui_evclaim_t taskbar_clock_kbd_event(taskbar_clock_t *clock, kbd_event_t *event)
{
        return ui_unclaimed;
}

/** Handle taskbar clock position event.
 *
 * @param clock Taskbar clock
 * @param event Position event
 * @return ui_claimed iff event was claimed
 */
ui_evclaim_t taskbar_clock_pos_event(taskbar_clock_t *clock, pos_event_t *event)
{
        gfx_coord2_t pos;

        pos.x = event->hpos;
        pos.y = event->vpos;
        if (!gfx_pix_inside_rect(&pos, &clock->rect))
                return ui_unclaimed;

        return ui_claimed;
}

/** Get base control for taskbar clock.
 *
 * @param clock Taskbar clock
 * @return Base UI control
 */
ui_control_t *taskbar_clock_ctl(taskbar_clock_t *clock)
{
        return clock->control;
}

/** Set taskbar clock rectangle.
 *
 * @param clock Taskbar clock
 * @param rect Rectangle
 */
void taskbar_clock_set_rect(taskbar_clock_t *clock, gfx_rect_t *rect)
{
        gfx_rect_t irect;

        clock->rect = *rect;

        irect.p0.x = clock->rect.p0.x + 1;
        irect.p0.y = clock->rect.p0.y + 1;
        irect.p1.x = clock->rect.p1.x;
        irect.p1.y = clock->rect.p1.y - 1;

        (void)irect;
}

/** Destroy clock control.
 *
 * @param arg Argument (taskbar_clock_t *)
 */
void taskbar_clock_ctl_destroy(void *arg)
{
        taskbar_clock_t *clock = (taskbar_clock_t *) arg;

        taskbar_clock_destroy(clock);
}

/** Paint taskbar clock control.
 *
 * @param arg Argument (taskbar_clock_t *)
 * @return EOK on success or an error code
 */
errno_t taskbar_clock_ctl_paint(void *arg)
{
        taskbar_clock_t *clock = (taskbar_clock_t *) arg;

        return taskbar_clock_paint(clock);
}

/** Handle taskbar clock control keyboard event.
 *
 * @param arg Argument (taskbar_clock_t *)
 * @param kbd_event Keyboard event
 * @return @c ui_claimed iff the event is claimed
 */
ui_evclaim_t taskbar_clock_ctl_kbd_event(void *arg, kbd_event_t *event)
{
        taskbar_clock_t *clock = (taskbar_clock_t *) arg;

        return taskbar_clock_kbd_event(clock, event);
}

/** Handle taskbar clock control position event.
 *
 * @param arg Argument (taskbar_clock_t *)
 * @param pos_event Position event
 * @return @c ui_claimed iff the event is claimed
 */
ui_evclaim_t taskbar_clock_ctl_pos_event(void *arg, pos_event_t *event)
{
        taskbar_clock_t *clock = (taskbar_clock_t *) arg;

        return taskbar_clock_pos_event(clock, event);
}

/** Taskbar clock timer handler.
 *
 * @param arg Argument (taskbar_clock_t *)
 */
static void taskbar_clock_timer(void *arg)
{
        taskbar_clock_t *clock = (taskbar_clock_t *) arg;
        ui_t *ui;

        ui = ui_window_get_ui(clock->window);
        ui_lock(ui);

        fibril_mutex_lock(&clock->lock);
        if (!ui_is_suspended(ui_window_get_ui(clock->window)))
                (void) taskbar_clock_paint(clock);

        if (!clock->timer_cleanup) {
                fibril_timer_set(clock->timer, 1000000, taskbar_clock_timer,
                    clock);
        } else {
                /* Acknowledge timer cleanup */
                clock->timer_done = true;
                fibril_condvar_signal(&clock->timer_done_cv);
        }

        fibril_mutex_unlock(&clock->lock);
        ui_unlock(ui);
}

/** @}
 */