apps/display-demo/app_desktop.c

Go to the documentation of this file.

#include <led.h>
#include <board.h>
#include <membag.h>
#include <string.h>
#include <mainloop.h>

#include <fs/tsfs.h>

#include <gfx/gfx.h>
#include <gfx/win.h>
#include <gfx/wtk.h>
#include <gfx/sysfont.h>

#include "app_desktop.h"
#include "app_calibrate.h"
#include "app_calc.h"
#include "app_clock.h"
#ifdef CONFIG_HUGEMEM
# include "app_fonts.h"
# include "app_slideshow.h"
# include "app_tank.h"
# include "app_files.h"
# include "app_memgame.h"
#endif
#include "app_widget.h"

#include "file_loader.h"


#define DESKTOP_NUM_APPS_PER_COLUMN     4

#define DESKTOP_NUM_APPS_PER_ROW        3

#define DESKTOP_APP_COUNT               (DESKTOP_NUM_APPS_PER_COLUMN * \
                DESKTOP_NUM_APPS_PER_ROW)



#define DESKTOP_BACKGROUND_COLOR        GFX_COLOR(0, 0, 0)

#define DESKTOP_ICON_TEXT_COLOR         GFX_COLOR(255, 255, 255)

#define DESKTOP_POPUP_BORDER_COLOR      GFX_COLOR(255, 42, 42)



#define DESKTOP_ICON_NAME_SIZE          9

#define DESKTOP_ICON_TEXT_SIZE          11

#define DESKTOP_ICON_SPACING_X          80

#define DESKTOP_ICON_SPACING_Y          80

#define DESKTOP_ICON_POS_X              11

#define DESKTOP_ICON_POS_Y              7

#define DESKTOP_ICON_SIZE_X             57

#define DESKTOP_ICON_SIZE_Y             57

#define DESKTOP_ICON_TEXT_X             (DESKTOP_ICON_SPACING_X / 2)

#define DESKTOP_ICON_TEXT_Y             ((DESKTOP_ICON_POS_Y + \
                        DESKTOP_ICON_SIZE_Y + DESKTOP_ICON_SPACING_Y) / 2)



#define DESKTOP_POPUP_PADDING           20

#define DESKTOP_POPUP_HEIGHT            (gfx_font_get_height(&sysfont) * 5)

#define DESKTOP_POPUP_WIDTH             (gfx_get_width() - 2 * \
                DESKTOP_POPUP_PADDING)

#define DESKTOP_POPUP_POS_X             DESKTOP_POPUP_PADDING

#define DESKTOP_POPUP_POS_Y             ((gfx_get_height() / 2) - \
                (DESKTOP_POPUP_HEIGHT / 2))


#define DESKTOP_REGISTER_APP(icon,text,start_task)  \
                { .icon_name = icon, .icon_text=text,.task=start_task }

struct app_desktop {
        struct workqueue_task desktop_worker_task;
        struct workqueue_task application_launcher_task;
        bool                  desktop_enabled;
};

static struct app_desktop the_app_desktop;

#ifdef CONFIG_FS_TSFS

extern struct tsfs              myfs;
#endif /* CONFIG_FS_TSFS */

struct app_config {
        char             icon_name[DESKTOP_ICON_NAME_SIZE];
        char             icon_text[DESKTOP_ICON_TEXT_SIZE];
        workqueue_func_t task;
};

struct app_config apps[DESKTOP_APP_COUNT] = {
        DESKTOP_REGISTER_APP("i_calc", "Calc", app_calc_launch),
        DESKTOP_REGISTER_APP("i_sett", "Widget", app_widget_launch),
        DESKTOP_REGISTER_APP("i_clock", "Clock", app_clock_launch),
#ifdef CONFIG_FS_TSFS
        DESKTOP_REGISTER_APP("i_fonts", "Fonts", app_fonts_launch),

        DESKTOP_REGISTER_APP("i_pics", "Pictures", app_slideshow_pics_launch),
        DESKTOP_REGISTER_APP("i_tank", "Water tank", app_tank_launch),
        DESKTOP_REGISTER_APP("i_files", "Files", app_files_launch),
        DESKTOP_REGISTER_APP("i_games", "Memory", app_memgame_launch),

        DESKTOP_REGISTER_APP("i_avr", "8-bit", app_slideshow_avr_launch),
        DESKTOP_REGISTER_APP("i_uc3", "32-bit", app_slideshow_uc3_launch),
        DESKTOP_REGISTER_APP("i_xmega", "XMEGA", app_slideshow_xmega_launch),
        DESKTOP_REGISTER_APP("i_avr", "This kit", app_slideshow_dx_launch),
#else
        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),

        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),
        DESKTOP_REGISTER_APP("", "", NULL),
#endif
};

static void app_desktop_enable(void)
{
        the_app_desktop.desktop_enabled = true;
}

static void app_desktop_disable(void)
{
        the_app_desktop.desktop_enabled = false;
}

static bool app_desktop_is_enabled(void)
{
        return the_app_desktop.desktop_enabled;
}

void app_desktop_restart(void)
{
        workqueue_add_task(&main_workqueue, &the_app_desktop.desktop_worker_task);
}


static void get_icon_pos(uint8_t iconnum, gfx_coord_t *x, gfx_coord_t *y)
{
        *x = iconnum % DESKTOP_NUM_APPS_PER_COLUMN * DESKTOP_ICON_SPACING_X;
        *y = iconnum / DESKTOP_NUM_APPS_PER_COLUMN * DESKTOP_ICON_SPACING_Y;
}

static void draw_icon_text(const char text[], gfx_coord_t center_x,
                gfx_coord_t center_y)
{
        gfx_coord_t x;
        gfx_coord_t y;

        gfx_get_string_bounding_box(text, &sysfont, &x, &y);
        gfx_draw_string((char *)text, center_x - x / 2, center_y - y / 2,
                        &sysfont, DESKTOP_ICON_TEXT_COLOR,
                        GFX_COLOR_TRANSPARENT);
}

#ifdef CONFIG_FS_TSFS

static void app_desktop_popup_empty_tsfs(void)
{
        gfx_draw_filled_rect(DESKTOP_POPUP_POS_X, DESKTOP_POPUP_POS_Y,
                        DESKTOP_POPUP_WIDTH, DESKTOP_POPUP_HEIGHT,
                        DESKTOP_BACKGROUND_COLOR);
        gfx_draw_rect(DESKTOP_POPUP_POS_X, DESKTOP_POPUP_POS_Y,
                        DESKTOP_POPUP_WIDTH, DESKTOP_POPUP_HEIGHT,
                        DESKTOP_POPUP_BORDER_COLOR);
        gfx_draw_string("Warning: file system empty, please program\n\n"
                        "the DataFlash to contain a proper TSFS image.",
                        DESKTOP_POPUP_POS_X + gfx_font_get_height(&sysfont),
                        DESKTOP_POPUP_POS_Y + gfx_font_get_width(&sysfont),
                        &sysfont, DESKTOP_ICON_TEXT_COLOR,
                        GFX_COLOR_TRANSPARENT);
}
#endif /* CONFIG_FS_TSFS */

static bool app_desktop_handler(struct win_window *win,
                enum win_event_type type, void const *data)
{
        static gfx_coord_t last_x;
        static gfx_coord_t last_y;
        static gfx_coord_t x = 0;
        static gfx_coord_t y = 0;

        // Do not do any event handling if desktop is not enabled
        if (!app_desktop_is_enabled()) {
                return true;
        }

        if (type == WIN_EVENT_POINTER) {
                // For POINTER events, the data parameter points to the pointer
                // event information.
                struct win_pointer_event const *event =
                                (struct win_pointer_event const *)data;
                uint8_t i;

                switch (event->type) {
                case WIN_POINTER_PRESS:
                        // Draw white outline around icon under the pointer.
                        x = event->pos.x / DESKTOP_ICON_SPACING_X;
                        y = event->pos.y / DESKTOP_ICON_SPACING_Y;

                        last_x = x * DESKTOP_ICON_SPACING_X;
                        last_y = y * DESKTOP_ICON_SPACING_Y;
                        gfx_draw_rect(last_x, last_y,
                                        DESKTOP_ICON_SPACING_X,
                                        DESKTOP_ICON_SPACING_Y,
                                        DESKTOP_ICON_TEXT_COLOR);
                        break;

                case WIN_POINTER_RELEASE:
                        /* Remove the white outline, then launch the application
                         * if an application launch worker function is set.
                         */
                        gfx_draw_rect(last_x, last_y,
                                        DESKTOP_ICON_SPACING_X,
                                        DESKTOP_ICON_SPACING_Y,
                                        DESKTOP_BACKGROUND_COLOR);

                        i = x + y * DESKTOP_NUM_APPS_PER_COLUMN;

                        if ((i < DESKTOP_APP_COUNT) && (apps[i].task)) {
                                app_desktop_disable();

                                workqueue_task_set_work_func
                                                (&the_app_desktop.application_launcher_task,
                                                apps[i].task);

                                workqueue_add_task(&main_workqueue,
                                                &the_app_desktop.application_launcher_task);
                        } else {
                                dbg_error("Not implemented\n");
                        }

                        break;

                default:
                        break;
                }
        }
        // Accept all events
        return true;
}


#ifdef CONFIG_FS_TSFS

static void load_desktop(struct workqueue_task *task)
{
        static uint8_t i = 0;
        gfx_coord_t x;
        gfx_coord_t y;
        enum status_code result;

        if (file_loader_busy()) {
                // Image loader busy, reschedule to check later
                workqueue_add_task(&main_workqueue, task);
                return;
        }

        // Check if we are finished
        if (i > DESKTOP_APP_COUNT) {
                /*
                 * Check if file system is empty, if empty encurage the user to
                 * fill the DataFlash with a TSFS image.
                 */
                if (!tsfs_nr_files(&myfs)) {
                        app_desktop_popup_empty_tsfs();
                }

                // Reset to be able to restart drawing background
                i = 0;
                // Enable event handling
                app_desktop_enable();
                return;
        }

        // Setup for first icon
        if (i == 0) {
                // Disable event handling
                app_desktop_disable();

                // Redraw background
                gfx_set_clipping(0, 0, gfx_get_width(), gfx_get_height());
                gfx_draw_filled_rect(0, 0, gfx_get_width(), gfx_get_height(),
                                DESKTOP_BACKGROUND_COLOR);
                win_redraw(win_get_root());
        }

        // Get icon position
        get_icon_pos(i, &x, &y);
        draw_icon_text(apps[i].icon_text, x + DESKTOP_ICON_TEXT_X,
                        y + DESKTOP_ICON_TEXT_Y);

        x += DESKTOP_ICON_POS_X;
        y += DESKTOP_ICON_POS_Y;

        // Load icon if it is specified
        if (strlen(apps[i].icon_name) > 0) {
                // Load image and schedule this task when done
                result = load_file_to_screen(apps[i].icon_name, x, y,
                                DESKTOP_ICON_SIZE_X, DESKTOP_ICON_SIZE_Y, task);

                if (result != STATUS_OK) {
                        // Unable to load icon, draw a cross instead
                        gfx_draw_rect(x, y, DESKTOP_ICON_SIZE_X,
                                        DESKTOP_ICON_SIZE_Y,
                                        DESKTOP_ICON_TEXT_COLOR);
                        gfx_draw_line(x, y, x + DESKTOP_ICON_SIZE_X - 1,
                                        y + DESKTOP_ICON_SIZE_Y - 1,
                                        DESKTOP_ICON_TEXT_COLOR);
                        gfx_draw_line(x, y + DESKTOP_ICON_SIZE_Y - 1,
                                        x + DESKTOP_ICON_SIZE_X - 1, y,
                                        DESKTOP_ICON_TEXT_COLOR);
                        // Reschedule for drawing next icon
                        workqueue_add_task(&main_workqueue, task);
                }
        } else {
                // Reschedule for drawing next icon
                workqueue_add_task(&main_workqueue, task);
        }
        // Load next icon
        i++;
}
#else

static void load_desktop(struct workqueue_task *task)
{
        uint8_t     i;
        uint8_t     shade;
        gfx_coord_t x;
        gfx_coord_t y;

        // Set up desktop
        app_desktop_disable();

        gfx_set_clipping(0, 0, gfx_get_width(), gfx_get_height());
        gfx_draw_filled_rect(0, 0, gfx_get_width(), gfx_get_height(),
                        DESKTOP_BACKGROUND_COLOR);
        win_redraw(win_get_root());

        // Set start color for blue shade
        shade = 128;
        for (i = 0; i < ARRAY_LEN(apps); i++) {
                get_icon_pos(i, &x, &y);
                draw_icon_text(apps[i].icon_text, x + DESKTOP_ICON_TEXT_X,
                                y + DESKTOP_ICON_TEXT_Y);

                x += DESKTOP_ICON_POS_X;
                y += DESKTOP_ICON_POS_Y;

                if (strlen(apps[i].icon_name) > 0) {
                        // Draw rectangles with the color for current application
                        gfx_draw_filled_rect(x, y, DESKTOP_ICON_SIZE_X,
                                        DESKTOP_ICON_SIZE_Y,
                                        gfx_color(76, 76, shade));
                        // Increment blue comonent to give the shading effect
                        shade += 6;
                }
        }

        app_desktop_enable();
}
#endif /* CONFIG_FS_TSFS */

void app_desktop_setup(void)
{
        struct win_window     *win_root;
        struct win_attributes attr;

        win_root = win_get_root();

        attr = *win_get_attributes(win_root);
        attr.background = NULL;
        attr.event_handler = app_desktop_handler;
        win_set_attributes(win_root, &attr,
                        WIN_ATTR_BACKGROUND | WIN_ATTR_EVENTHANDLER);

        win_show(win_root);

#ifdef CONFIG_FS_TSFS
        file_loader_init();
#endif
        workqueue_task_init(&the_app_desktop.desktop_worker_task, load_desktop);
        workqueue_task_init(&the_app_desktop.application_launcher_task, NULL);

#if CONFIG_GFX_WIN_USE_TOUCH
        app_touch_calibrate_setup(&the_app_desktop.desktop_worker_task);
#else
        workqueue_add_task(&main_workqueue,
                        &the_app_desktop.desktop_worker_task);
#endif
}

---