X-Git-Url: https://git.karo-electronics.de/?a=blobdiff_plain;f=ui%2Foswald_screens.c;h=ab7140847b2bc4e6d9aac37779b284045e4eefa6;hb=f9c26e3f61a2d9bc1070cef0f6f08bd6f6240849;hp=b6158d81cd3cf647179e9540e7d4a0cd98340a33;hpb=019424a494c8312fd8bac9eb89839aea943f4d88;p=oswald.git diff --git a/ui/oswald_screens.c b/ui/oswald_screens.c index b6158d8..ab71408 100644 --- a/ui/oswald_screens.c +++ b/ui/oswald_screens.c @@ -1,81 +1,825 @@ +#include + #include "oswald.h" +#include "oswald_main.h" #include "oswald_watch_faces.h" -#include "Fonts.h" -#include "LcdDisplay.h" +#include "oswald_graphics.h" +#include "oswald_hal.h" #include "oswald_screens.h" -void idle_handle_user_buttons(watch_button button) +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/startstopbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/lapsebutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/upbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/downbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/leftbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/rightbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/enterbutton_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/checked_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/unchecked_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/main_menu_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/timesetup_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/stopwatch_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/alarm_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/Bluetooth_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/info_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/acc_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/Message_icon.xbm" + +#if defined(__GNUC__) && (__MSP430X__ > 0) +__attribute__((__far__)) +#endif +#include "bitmaps/Exit_icon.xbm" + + +/* + * Common event handler part of the watch faces + */ +typedef struct { + void (*screendraw_func)(boolean show_seconds); + boolean show_seconds; + boolean analogue; +} idle_data_t; +static idle_data_t idle_screen = { + DrawLcdDigitalClock, + TRUE, + FALSE, +}; + +event_ret_t idle_handle_user_buttons(watch_button button) { + switch (button) { + case BUTTON_A: + if (idle_screen.show_seconds) + idle_screen.show_seconds = FALSE; + else + idle_screen.show_seconds = TRUE; + break; + case BUTTON_B: + if (idle_screen.analogue == TRUE) { + idle_screen.analogue = FALSE; + idle_screen.screendraw_func = DrawLcdDigitalClock; + } else { + idle_screen.analogue = TRUE; + idle_screen.screendraw_func = DrawLcdAnaClock; + }; + break; + case BUTTON_C: + OswaldState.screen_id = MAIN_MENU_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + return EVENT_RET_HANDLED; + break; + case BUTTON_F: + OswaldState.screen_id = DATETIME_SETTING_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + + idle_screen.screendraw_func(idle_screen.show_seconds); + + return EVENT_RET_HANDLED; } -void idle_handle_events(u16t event, void *data) + +event_ret_t idle_handle_events(uint16_t event, void *data) { switch (event) { case EVENT_ONE_SEC_TIMER: case EVENT_SCREEN_VISIBLE: - DrawLcdDigitalClock(); + idle_screen.screendraw_func(idle_screen.show_seconds); + return EVENT_RET_HANDLED; break; case EVENT_USER_BUTTONS: dbg_out("button event %d\n", *(int *)data); + return idle_handle_user_buttons(*(watch_button *)data); break; default: + return EVENT_RET_UNHANDLED; break; }; + return EVENT_RET_UNHANDLED; } -void draw_accel_screen(void) + +/* + * Main Menu Screen + */ +typedef struct { + int8_t pos; + uint8_t tmo; +} main_menu_data_t; +static main_menu_data_t main_menu_screen = { + ALARM_SETUP_SCREEN, + 0, +}; + +#define MAIN_MENU_GRID_PIXEL 84 +#define MAIN_MENU_GRID_X 3 +// GRID_Y is +1 since there is one empty row for title icon +#define MAIN_MENU_GRID_Y 3 +#define MAIN_MENU_GRID_SPACING 0 +#define MAIN_MENU_OFFSET_X 3 +#define MAIN_MENU_OFFSET_Y 10 + +void draw_main_menu_screen(main_menu_data_t *sdata) { - lcd_clear_display(); - SetFont(MetaWatch16); - WriteLcdString(2, 2, "X:"); - WriteLcdString(20, 2, "123"); - WriteLcdString(2, 18, "Z:"); - WriteLcdString(20, 18, "123"); - WriteLcdString(2, 34, "Y:"); - WriteLcdString(20, 34, "123"); + uint8_t pf = sdata->pos - 2; + + hal_lcd_clear_display(); + +// oswald_draw_bitmap(36, 0, main_menu_icon_width, main_menu_icon_height, main_menu_icon_bits); + + oswald_draw_bitmap(81, 6, rightbutton_icon_width, rightbutton_icon_height, rightbutton_icon_bits); + oswald_draw_bitmap(81, 38, leftbutton_icon_width, leftbutton_icon_height, leftbutton_icon_bits); + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((0+1) * MAIN_MENU_GRID_SPACING) + (0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + alarm_icon_width, alarm_icon_height, alarm_icon_bits, (sdata->pos == ALARM_SETUP_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((1+1) * MAIN_MENU_GRID_SPACING) + (1 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + stopwatch_icon_width, stopwatch_icon_height, stopwatch_icon_bits, (sdata->pos == STOP_WATCH_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((2+1) * MAIN_MENU_GRID_SPACING) + (2 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + Bluetooth_icon_width, Bluetooth_icon_height, Bluetooth_icon_bits, (sdata->pos == BLUETOOTH_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((0+1) * MAIN_MENU_GRID_SPACING) + (0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(1 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + acc_icon_width, acc_icon_height, acc_icon_bits, (sdata->pos == ACCEL_DISPLAY_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((1+1) * MAIN_MENU_GRID_SPACING) + (1 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(1 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + Message_icon_width, Message_icon_height, Message_icon_bits, (sdata->pos == MESSAGES_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((2+1) * MAIN_MENU_GRID_SPACING) + (2 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(1 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + info_icon_width, info_icon_height, info_icon_bits, (sdata->pos == INFO_SCREEN)); + oswald_draw_bitmpa_invert_opt(MAIN_MENU_OFFSET_X+((0+1) * MAIN_MENU_GRID_SPACING) + (0 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+(2 * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), + Exit_icon_width, Exit_icon_height, Exit_icon_bits, (sdata->pos == LAST_SCREEN)); + + // round the corners of the inverted icon a little + hal_lcd_set_pixel(MAIN_MENU_OFFSET_X+((pf%MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)) % (MAIN_MENU_GRID_X*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+((pf/MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)) % (MAIN_MENU_GRID_Y*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), FALSE); + hal_lcd_set_pixel(MAIN_MENU_OFFSET_X+23+((pf%MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)) % (MAIN_MENU_GRID_X*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+((pf/MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)) % (MAIN_MENU_GRID_Y*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), FALSE); + hal_lcd_set_pixel(MAIN_MENU_OFFSET_X+((pf%MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)) % (MAIN_MENU_GRID_X*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+23+((pf/MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)) % (MAIN_MENU_GRID_Y*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), FALSE); + hal_lcd_set_pixel(MAIN_MENU_OFFSET_X+23+((pf%MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)) % (MAIN_MENU_GRID_X*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_X)), + MAIN_MENU_OFFSET_Y+23+((pf/MAIN_MENU_GRID_X) * (MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)) % (MAIN_MENU_GRID_Y*(MAIN_MENU_GRID_PIXEL / MAIN_MENU_GRID_Y)), FALSE); + + hal_lcd_update_display(); +} + +event_ret_t handle_main_menu_buttons(watch_button button, main_menu_data_t *sdata) +{ + switch (button) { + case BUTTON_A: + sdata->pos++; + if (sdata->pos > LAST_SCREEN) + sdata->pos = 2; + draw_main_menu_screen(&main_menu_screen); + return EVENT_RET_HANDLED; + break; + case BUTTON_B: + sdata->pos--; + if (sdata->pos < 2) + sdata->pos = LAST_SCREEN; + draw_main_menu_screen(&main_menu_screen); + return EVENT_RET_HANDLED; + break; + case BUTTON_C: + if (sdata->pos < LAST_SCREEN) { + OswaldState.screen_id = sdata->pos; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + } else { + OswaldState.screen_id = IDLE_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + } + return EVENT_RET_HANDLED; + break; + default: + break; + } + + return EVENT_RET_UNHANDLED; } -void accel_handle_events(u16t event, void *data) + +/* after MAIN_MENU_TIMEOUT seconds return to IDLE_SCREEN */ +#define MAIN_MENU_TIMEOUT 10 + +event_ret_t main_menu_handle_events(uint16_t event, void *data) { switch (event) { case EVENT_SCREEN_VISIBLE: - draw_accel_screen(); + main_menu_screen.tmo = 0; + main_menu_screen.pos = 2; + draw_main_menu_screen(&main_menu_screen); + return EVENT_RET_HANDLED; break; case EVENT_USER_BUTTONS: dbg_out("button event %d\n", *(int *)data); + main_menu_screen.tmo = 0; + return handle_main_menu_buttons(*(watch_button *)data, &main_menu_screen); break; + case EVENT_ONE_SEC_TIMER: + main_menu_screen.tmo++; + if (main_menu_screen.tmo > MAIN_MENU_TIMEOUT) { + OswaldState.screen_id = IDLE_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + } + return EVENT_RET_HANDLED; default: break; }; + return EVENT_RET_UNHANDLED; } -void draw_datetime_setup_screen(void) + +/* + * Accelerometer and sensor display screen + */ +typedef struct { + accel_data_t accdata; +} accelscreen_data_t; +static accelscreen_data_t accel_screen = { + { 0, 0, 0}, +}; + +void draw_accel_screen(accel_data_t *accel_data) { - lcd_clear_display(); - SetFont(MetaWatch16); - WriteLcdString(2, 2, "Date / Time"); - WriteLcdString(2, 18, "Setting"); - WriteLcdString(2, 34, "22:39"); - WriteLcdString(2, 50, "07.08.2012"); + uint8_t x,y; + + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, acc_icon_width, acc_icon_height, acc_icon_bits); + + oswald_draw_bitmap(81, 79, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + oswald_write_string(1, 40, FONT_6x9, FALSE, "X:"); + oswald_write_number(15, 40, FONT_6x9, FALSE, accel_data->x); + oswald_write_string(1, 52, FONT_6x9, FALSE, "Y:"); + oswald_write_number(15, 52, FONT_6x9, FALSE, accel_data->y); + oswald_write_string(1, 64, FONT_6x9, FALSE, "Z:"); + oswald_write_number(15, 64, FONT_6x9, FALSE, accel_data->z); + + oswald_write_string(1, 85, FONT_6x9, FALSE, "Light:"); + oswald_write_number(50, 85, FONT_6x9, FALSE, 0); + + oswald_draw_line(40, 30, 92, 30); + oswald_draw_line(92, 30, 92, 82); + oswald_draw_line(40, 82, 92, 82); + oswald_draw_line(40, 82, 40, 30); + + x = 41+25+((accel_data->x * 50) / (254)); + y = 31+25-((accel_data->y * 50) / (254)); + oswald_draw_pixel(x, y, TRUE); + oswald_draw_pixel(x+1, y, TRUE); + oswald_draw_pixel(x-1, y, TRUE); + oswald_draw_pixel(x, y+1, TRUE); + oswald_draw_pixel(x, y-1, TRUE); + + hal_lcd_update_display(); +} + +event_ret_t accel_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + draw_accel_screen(&accel_screen.accdata); + hal_accelerometer_enable(); + return EVENT_RET_HANDLED; + break; + case EVENT_SCREEN_DESTROY: + hal_accelerometer_disable(); + return EVENT_RET_HANDLED; + break; + case EVENT_ACCEL_UPDATE: { + accel_data_t *accel_data = (accel_data_t *)data; + accel_screen.accdata.x = accel_data->x; + accel_screen.accdata.y = accel_data->y; + accel_screen.accdata.z = accel_data->z; + draw_accel_screen(&accel_screen.accdata); + }; + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_UNHANDLED; +} + + +/* + * Date / time setup screen + */ +typedef struct { + uint8_t pos; + boolean set_mode; + boolean on; +} datetime_setup_data_t; +static datetime_setup_data_t dt_setup_screen = { + 0, + FALSE, + TRUE +}; + +void draw_datetime_setup_screen(datetime_setup_data_t *sdata) +{ + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, timesetup_icon_width, timesetup_icon_height, timesetup_icon_bits); + + oswald_draw_bitmap(81, 6, upbutton_icon_width, upbutton_icon_height, upbutton_icon_bits); + oswald_draw_bitmap(81, 38, downbutton_icon_width, downbutton_icon_height, downbutton_icon_bits); + oswald_draw_bitmap(81, 70, rightbutton_icon_width, rightbutton_icon_height, rightbutton_icon_bits); + + if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) { + oswald_write_character(2, 30, FONT_LCD13x21, FALSE, (OswaldClk.hour / 10)); + oswald_write_character(15, 30, FONT_LCD13x21, FALSE, (OswaldClk.hour % 10)); + } + oswald_write_character(25, 30, FONT_LCD13x21, FALSE, 10); + + if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) { + oswald_write_character(34, 30, FONT_LCD13x21, FALSE, (OswaldClk.minute / 10)); + oswald_write_character(47, 30, FONT_LCD13x21, FALSE, (OswaldClk.minute % 10)); + } + + if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) { + oswald_write_character(61, 38, FONT_LCD8x13, FALSE, (OswaldClk.second / 10)); + oswald_write_character(69, 38, FONT_LCD8x13, FALSE, (OswaldClk.second % 10)); + } + + + if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) { + oswald_write_number(2, 55, FONT_DROID8x12, FALSE, OswaldClk.day); + } + oswald_write_character(15, 55, FONT_DROID8x12, FALSE, '.'); + if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) { + oswald_write_number(21, 55, FONT_DROID8x12, FALSE, OswaldClk.month); + } + oswald_write_character(36, 55, FONT_DROID8x12, FALSE, '.'); + if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) { + oswald_write_number(43, 55, FONT_DROID8x12, FALSE, OswaldClk.year); + } + + if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) { + if (OswaldClk.clk24hr) { + oswald_draw_bitmap(2, 76, checked_icon_width, checked_icon_height, checked_icon_bits); + } else { + oswald_draw_bitmap(2, 76, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + } + oswald_write_string(15, 73, FONT_DROID8x12, FALSE, "24hr"); + + if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) { + if (OswaldClk.day_first) { + oswald_draw_bitmap(2, 86, checked_icon_width, checked_icon_height, checked_icon_bits); + } else { + oswald_draw_bitmap(2, 86, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + } + oswald_write_string(15, 83, FONT_DROID8x12, FALSE, "dd.mm. mm/dd"); + + hal_lcd_update_display(); +} + +void datetime_handle_updown(uint8_t pos, int8_t incr) +{ + switch (pos) { + case 0: // hour + if (OswaldClk.hour == 0 && incr == -1) { + OswaldClk.hour = 23; + break; + }; + OswaldClk.hour += incr; + if (OswaldClk.hour > 23) + OswaldClk.hour = 0; + break; + case 1: // minute + if (OswaldClk.minute == 0 && incr == -1) { + OswaldClk.minute = 59; + break; + }; + OswaldClk.minute += incr; + if (OswaldClk.minute > 59) + OswaldClk.minute = 0; + break; + case 2: // second + OswaldClk.second = 0; + break; + case 3: // day + if (OswaldClk.day == 1 && incr == -1) { + OswaldClk.day = 31; + break; + }; + OswaldClk.day += incr; + if (OswaldClk.day > 31) + OswaldClk.day = 1; + break; + case 4: // month + if (OswaldClk.month == 1 && incr == -1) { + OswaldClk.month = 12; + break; + }; + OswaldClk.month += incr; + if (OswaldClk.month > 12) + OswaldClk.month = 1; + break; + case 5: // year + OswaldClk.year += incr; + break; + case 6: // 24hr / 12hr + if (OswaldClk.clk24hr) + OswaldClk.clk24hr = FALSE; + else + OswaldClk.clk24hr = TRUE; + break; + case 7: // dd.mm. / mm/dd + if (OswaldClk.day_first) + OswaldClk.day_first = FALSE; + else + OswaldClk.day_first = TRUE; + break; + default: + break; + }; + if (pos == 2) + hal_set_rtc(&OswaldClk, TRUE); + else + hal_set_rtc(&OswaldClk, FALSE); +} + +event_ret_t handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata) +{ + switch (button) { + case BUTTON_A: + datetime_handle_updown(sdata->pos, 1); + break; + case BUTTON_B: + datetime_handle_updown(sdata->pos, -1); + break; + case BUTTON_C: + sdata->pos++; + sdata->pos %= 8; + break; + case BUTTON_F: + OswaldState.screen->event_func(EVENT_SCREEN_DESTROY, NULL); + OswaldState.screen_id = IDLE_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + draw_datetime_setup_screen(sdata); + return EVENT_RET_HANDLED; +} + +event_ret_t datetime_setup_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + dt_setup_screen.pos = 0; + draw_datetime_setup_screen(&dt_setup_screen); + hal_enable_halfsecond_timer(); + return EVENT_RET_HANDLED; + break; + case EVENT_SCREEN_DESTROY: + hal_disable_halfsecond_timer(); + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + return handle_setup_datetime_buttons(*(watch_button *)data, &dt_setup_screen); + break; + case EVENT_HALF_SEC_TIMER: + if (dt_setup_screen.on) + dt_setup_screen.on = FALSE; + else + dt_setup_screen.on = TRUE; + draw_datetime_setup_screen(&dt_setup_screen); + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_UNHANDLED; +} + + +/* + * Alarm setup screen + */ +typedef struct { + uint8_t pos; + boolean set_mode; + boolean on; +} alarm_setup_data_t; +static alarm_setup_data_t alarm_setup_screen = { + 0, + FALSE, + TRUE +}; + +void draw_alarm_setup_screen(alarm_setup_data_t *sdata) +{ + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, alarm_icon_width, alarm_icon_height, alarm_icon_bits); + + if (sdata->set_mode) { + oswald_draw_bitmap(81, 6, upbutton_icon_width, upbutton_icon_height, upbutton_icon_bits); + oswald_draw_bitmap(81, 38, downbutton_icon_width, downbutton_icon_height, downbutton_icon_bits); + oswald_draw_bitmap(81, 70, rightbutton_icon_width, rightbutton_icon_height, rightbutton_icon_bits); + } else { + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + } + + if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) { + oswald_write_character(18, 30, FONT_LCD13x21, FALSE, (OswaldAlarm.hour / 10)); + oswald_write_character(32, 30, FONT_LCD13x21, FALSE, (OswaldAlarm.hour % 10)); + } + oswald_write_character(42, 30, FONT_LCD13x21, FALSE, 10); + + if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) { + oswald_write_character(53, 30, FONT_LCD13x21, FALSE, (OswaldAlarm.minute / 10)); + oswald_write_character(67, 30, FONT_LCD13x21, FALSE, (OswaldAlarm.minute % 10)); + } + + oswald_write_character(3, 55, FONT_6x9, FALSE, 'S'); + oswald_write_character(15, 55, FONT_6x9, FALSE, 'M'); + oswald_write_character(27, 55, FONT_6x9, FALSE, 'T'); + oswald_write_character(39, 55, FONT_6x9, FALSE, 'W'); + oswald_write_character(51, 55, FONT_6x9, FALSE, 'T'); + oswald_write_character(63, 55, FONT_6x9, FALSE, 'F'); + oswald_write_character(75, 55, FONT_6x9, FALSE, 'S'); + + if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) { + // oswald_write_character(3, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_SUNDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_SUNDAY)) + oswald_draw_bitmap(3, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(3, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) { + // oswald_write_character(15, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_MONDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_MONDAY)) + oswald_draw_bitmap(15, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(15, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) { + // oswald_write_character(27, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_TUESDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_TUESDAY)) + oswald_draw_bitmap(27, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(27, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) { + // oswald_write_character(39, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_WEDNESDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_WEDNESDAY)) + oswald_draw_bitmap(39, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(39, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) { + // oswald_write_character(51, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_THURSDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_THURSDAY)) + oswald_draw_bitmap(51, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(51, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) { + // oswald_write_character(63, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_FRIDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_FRIDAY)) + oswald_draw_bitmap(63, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(63, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + if ((sdata->pos == 8 && sdata->on) || sdata->pos != 8) { + // oswald_write_character(75, 65, FONT_6x9, (OswaldAlarm.wday & WDAY_SATURDAY) ? 'x' : '_'); + if ((OswaldAlarm.wday & WDAY_SATURDAY)) + oswald_draw_bitmap(75, 66, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(75, 66, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + + hal_lcd_update_display(); } -void datetime_setup_events(u16t event, void *data) + +void alarm_handle_updown(uint8_t pos, int8_t incr) +{ + switch (pos) { + case 0: // hour + if (OswaldAlarm.hour == 0 && incr == -1) { + OswaldAlarm.hour = 23; + break; + }; + OswaldAlarm.hour += incr; + if (OswaldAlarm.hour > 23) + OswaldAlarm.hour = 0; + break; + case 1: // minute + if (OswaldAlarm.minute == 0 && incr == -1) { + OswaldAlarm.minute = 59; + break; + }; + OswaldAlarm.minute += incr; + if (OswaldAlarm.minute > 59) + OswaldAlarm.minute = 0; + break; + case 2: // sunday + OswaldAlarm.wday ^= WDAY_SUNDAY; + break; + case 3: // monday + OswaldAlarm.wday ^= WDAY_MONDAY; + break; + case 4: // tuesday + OswaldAlarm.wday ^= WDAY_TUESDAY; + break; + case 5: // wednesday + OswaldAlarm.wday ^= WDAY_WEDNESDAY; + break; + case 6: // thursday + OswaldAlarm.wday ^= WDAY_THURSDAY; + break; + case 7: // friday + OswaldAlarm.wday ^= WDAY_FRIDAY; + break; + case 8: // saturday + OswaldAlarm.wday ^= WDAY_SATURDAY; + break; + default: + break; + }; +} + +event_ret_t handle_setup_alarm_buttons(watch_button button, alarm_setup_data_t *sdata) +{ + if (alarm_setup_screen.set_mode) { + switch (button) { + case BUTTON_A: + alarm_handle_updown(sdata->pos, 1); + break; + case BUTTON_B: + alarm_handle_updown(sdata->pos, -1); + break; + case BUTTON_C: + sdata->pos++; + sdata->pos %= 9; + break; + case BUTTON_F: + alarm_setup_screen.set_mode = FALSE; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + } else { + switch (button) { + case BUTTON_F: + alarm_setup_screen.set_mode = TRUE; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + } + draw_alarm_setup_screen(sdata); + + return EVENT_RET_HANDLED; +} + +event_ret_t alarm_setup_events(uint16_t event, void *data) { switch (event) { case EVENT_SCREEN_VISIBLE: - draw_datetime_setup_screen(); + alarm_setup_screen.pos = 0; + alarm_setup_screen.on = TRUE; + alarm_setup_screen.set_mode = FALSE; + draw_alarm_setup_screen(&alarm_setup_screen); + hal_enable_halfsecond_timer(); + return EVENT_RET_HANDLED; + break; + case EVENT_SCREEN_DESTROY: + hal_disable_halfsecond_timer(); + return EVENT_RET_HANDLED; break; case EVENT_USER_BUTTONS: dbg_out("button event %d\n", *(int *)data); + return handle_setup_alarm_buttons(*(watch_button *)data, &alarm_setup_screen); + break; + case EVENT_HALF_SEC_TIMER: + if (alarm_setup_screen.set_mode) { + if (alarm_setup_screen.on) + alarm_setup_screen.on = FALSE; + else + alarm_setup_screen.on = TRUE; + } else + alarm_setup_screen.on = TRUE; + draw_alarm_setup_screen(&alarm_setup_screen); + return EVENT_RET_HANDLED; break; default: + return EVENT_RET_UNHANDLED; break; }; + return EVENT_RET_UNHANDLED; } -static u8t test_menu_pos = 0; + +/* + * Test menu + */ +typedef struct { + uint8_t menu_pos; +} test_menu_t; +static test_menu_t test_menu = { 0 }; void draw_menu_test_screen(void) { - lcd_clear_display(); + hal_lcd_clear_display(); +#if 0 SetFont(MetaWatch16); WriteLcdString(2, 2, "Menu"); SetFont(MetaWatch7); @@ -85,39 +829,691 @@ void draw_menu_test_screen(void) WriteLcdString(2, 47, "Item 4"); WriteLcdString(2, 56, "Item 5"); - WriteLcdString(50, 20+(9*test_menu_pos), "*"); + WriteLcdString(50, 20+(9*test_menu.menu_pos), "*"); +#endif + oswald_write_string(2, 2, FONT_DROID8x12, FALSE, "Menu"); + + oswald_write_string(2, 20, FONT_DROID8x12, FALSE, "Item 1"); + oswald_write_string(2, 29, FONT_DROID8x12, FALSE, "Item 2"); + oswald_write_string(2, 38, FONT_DROID8x12, FALSE, "Item 3"); + oswald_write_string(2, 47, FONT_DROID8x12, FALSE, "Item 4"); + oswald_write_string(2, 56, FONT_DROID8x12, FALSE, "Item 5"); + + oswald_write_character(50, 18+(9*test_menu.menu_pos), FONT_6x9, FALSE, 0x11); + + hal_lcd_update_display(); } -static void handle_menu_user_buttons(watch_button button) +event_ret_t handle_menu_user_buttons(watch_button button) { switch (button) { case BUTTON_A: - test_menu_pos--; - test_menu_pos%=5; + test_menu.menu_pos--; + test_menu.menu_pos %= 5; break; case BUTTON_B: - test_menu_pos++; - test_menu_pos%=5; + test_menu.menu_pos++; + test_menu.menu_pos %= 5; break; default: + return EVENT_RET_UNHANDLED; break; } draw_menu_test_screen(); + return EVENT_RET_HANDLED; } -void test_menu_handle_events(u16t event, void *data) +event_ret_t test_menu_handle_events(uint16_t event, void *data) { switch (event) { case EVENT_USER_BUTTONS: dbg_out("button event %d\n", *(int *)data); - handle_menu_user_buttons(*(watch_button *)data); + return handle_menu_user_buttons(*(watch_button *)data); break; case EVENT_SCREEN_VISIBLE: - test_menu_pos = 0; + test_menu.menu_pos = 0; draw_menu_test_screen(); break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_HANDLED; +} + + +/* + * Stop Watch + */ +typedef struct { + uint8_t hr; + uint8_t min; + uint8_t sec; + uint8_t csec; + uint8_t lapse_hr; + uint8_t lapse_min; + uint8_t lapse_sec; + uint8_t lapse_csec; + boolean running; +} stopwatch_data_t; +static stopwatch_data_t stopwatch_screen = { 0, 0, 0, 0, 0, 0, 0, 0, FALSE }; + + +static void draw_stop_watch_screen(stopwatch_data_t *sdata) +{ + int gRow = 1; + int gColumn = 35; + + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, stopwatch_icon_width, stopwatch_icon_height, stopwatch_icon_bits); + + oswald_draw_bitmap(81, 6, startstopbutton_icon_width, startstopbutton_icon_height, startstopbutton_icon_bits); + oswald_draw_bitmap(81, 38, lapsebutton_icon_width, lapsebutton_icon_height, lapsebutton_icon_bits); + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + gRow += 3 + oswald_write_character(gRow, gColumn, FONT_LCD13x21, FALSE, (sdata->hr % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD13x21, FALSE, (sdata->min / 10)); + gRow += 3 + oswald_write_character(gRow, gColumn, FONT_LCD13x21, FALSE, (sdata->min % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD13x21, FALSE, (sdata->sec / 10)); + gRow += 3 + oswald_write_character(gRow, gColumn, FONT_LCD13x21, FALSE, (sdata->sec % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->csec / 10)); + + gRow = 6; + gColumn = 61; + gRow += 13 + oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_hr % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_min / 10)); + gRow += 13 + oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_min % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_sec / 10)); + gRow += 3 + oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_sec % 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_csec / 10)); + gRow += oswald_write_character(gRow, gColumn, FONT_LCD8x13, FALSE, (sdata->lapse_csec % 10)); + + hal_lcd_update_display(); +} + +event_ret_t handle_stop_watch_buttons(watch_button button) +{ + switch (button) { + case BUTTON_A: // start/stop + if (stopwatch_screen.running) { + hal_disable_centisecond_timer(); + stopwatch_screen.running = FALSE; + } else { + hal_enable_centisecond_timer(); + stopwatch_screen.running = TRUE; + } + return EVENT_RET_HANDLED; + break; + case BUTTON_B: // lapse + stopwatch_screen.lapse_hr = stopwatch_screen.hr; + stopwatch_screen.lapse_min = stopwatch_screen.min; + stopwatch_screen.lapse_sec = stopwatch_screen.sec; + stopwatch_screen.lapse_csec = stopwatch_screen.csec; + return EVENT_RET_HANDLED; + break; + case BUTTON_F: // reset + stopwatch_screen.hr = 0; + stopwatch_screen.min = 0; + stopwatch_screen.sec = 0; + stopwatch_screen.csec = 0; + stopwatch_screen.lapse_hr = 0; + stopwatch_screen.lapse_min = 0; + stopwatch_screen.lapse_sec = 0; + stopwatch_screen.lapse_csec = 0; + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + return EVENT_RET_UNHANDLED; +} + +event_ret_t stop_watch_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + draw_stop_watch_screen(&stopwatch_screen); + return handle_stop_watch_buttons(*(watch_button *)data); + break; + case EVENT_SCREEN_VISIBLE: + draw_stop_watch_screen(&stopwatch_screen); + return EVENT_RET_HANDLED; + break; + case EVENT_SCREEN_DESTROY: + hal_disable_centisecond_timer(); + stopwatch_screen.running = FALSE; + return EVENT_RET_HANDLED; + break; + case EVENT_CS_TIMER: + stopwatch_screen.csec++; + if (stopwatch_screen.csec > 99) { + stopwatch_screen.csec = 0; + stopwatch_screen.sec++; + }; + if (stopwatch_screen.sec > 59) { + stopwatch_screen.sec = 0; + stopwatch_screen.min++; + }; + if (stopwatch_screen.min > 59) { + stopwatch_screen.min = 0; + stopwatch_screen.hr++; + }; + if (stopwatch_screen.hr > 59) { + stopwatch_screen.hr = 0; + }; + if (stopwatch_screen.csec % 10 == 0) + draw_stop_watch_screen(&stopwatch_screen); + //update_stop_watch_screen(&stopwatch_screen); + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_HANDLED; +} + + +/* + * Alarm screen, shown when alarm is fired + */ +void draw_alarm_screen(void) +{ + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 20, alarm_icon_width, alarm_icon_height, alarm_icon_bits); + + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + hal_lcd_update_display(); +} + +event_ret_t alarm_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + draw_alarm_screen(); + hal_enable_halfsecond_timer(); + hal_vibration_set_state(TRUE); + return EVENT_RET_HANDLED; + break; + case EVENT_SCREEN_DESTROY: + hal_disable_halfsecond_timer(); + hal_lcd_set_backlight(FALSE); + hal_vibration_set_state(FALSE); + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + return EVENT_RET_UNHANDLED; + break; + case EVENT_HALF_SEC_TIMER: + hal_lcd_set_backlight(!hal_lcd_get_backlight()); + hal_vibration_set_state(!hal_vibration_get_state()); + dbg_out("timer\n"); + return EVENT_RET_HANDLED; + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_HANDLED; +} + + +/* + * Bluetooth setup screen + */ +typedef struct { + uint8_t pos; + boolean bt_en; + boolean set_mode; + boolean on; +} bluetooth_data_t; +static bluetooth_data_t bluetooth_screen = { + 0, + FALSE, + FALSE, + TRUE +}; + +void draw_bluetooth_screen(bluetooth_data_t *sdata) +{ + char bstr[20]; + uint8_t *bd_addr; + + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, Bluetooth_icon_width, Bluetooth_icon_height, Bluetooth_icon_bits); + + if (sdata->set_mode) { + oswald_draw_bitmap(81, 6, upbutton_icon_width, upbutton_icon_height, upbutton_icon_bits); + oswald_draw_bitmap(81, 38, downbutton_icon_width, downbutton_icon_height, downbutton_icon_bits); + oswald_draw_bitmap(81, 70, rightbutton_icon_width, rightbutton_icon_height, rightbutton_icon_bits); + } else { + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + } + + oswald_write_string(1, 30, FONT_DROID8x12, FALSE, "Enable:"); + if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) { + if (bluetooth_screen.bt_en) + oswald_draw_bitmap(53, 33, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(53, 33, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + oswald_write_string(1, 40, FONT_DROID8x12, FALSE, "State:"); + switch (hal_bluetooth_get_state()) { + case BLUETOOTH_OFF: + oswald_write_string(53, 40, FONT_DROID8x12, FALSE, "off"); + break; + case BLUETOOTH_ON: + oswald_write_string(53, 40, FONT_DROID8x12, FALSE, "on"); + break; + case BLUETOOTH_CONNECTED: + oswald_write_string(53, 40, FONT_DROID8x12, FALSE, "conn."); + break; + default: + break; + }; + oswald_write_string(1, 50, FONT_DROID8x12, FALSE, "Visible:"); + if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) { + // oswald_write_character(53, 50, FONT_DROID8x12, hal_bluetooth_get_visible() ? 'x' : '_'); + if (hal_bluetooth_get_visible()) + oswald_draw_bitmap(53, 53, checked_icon_width, checked_icon_height, checked_icon_bits); + else + oswald_draw_bitmap(53, 53, unchecked_icon_width, unchecked_icon_height, unchecked_icon_bits); + } + + if (hal_bluetooth_get_state() >= BLUETOOTH_ON) { + bd_addr = hal_bluetooth_get_local_bdaddr(); + snprintf(bstr, 20, "%02x:%02x:%02x:%02x:%02x:%02x", bd_addr[5], bd_addr[4], bd_addr[3], bd_addr[2], bd_addr[1], bd_addr[0]); + oswald_write_string(2, 85, FONT_5x7, FALSE, bstr); + } else { + } + + hal_lcd_update_display(); +} + +void bluetooth_handle_updown(uint8_t pos, int8_t incr) +{ + switch (pos) { + case 0: + if (hal_bluetooth_get_state() >= BLUETOOTH_ON) { + hal_bluetooth_set_state(BLUETOOTH_OFF); + bluetooth_screen.bt_en = FALSE; + } else { + hal_bluetooth_set_state(BLUETOOTH_ON); + bluetooth_screen.bt_en = TRUE; + } + break; + case 1: + if (hal_bluetooth_get_state() >= BLUETOOTH_ON && !hal_bluetooth_get_visible()) { + hal_bluetooth_set_visible(TRUE); + } else { + hal_bluetooth_set_visible(FALSE); + } + break; + default: + break; + }; +} + +event_ret_t handle_bluetooth_buttons(watch_button button, bluetooth_data_t *sdata) +{ + if (bluetooth_screen.set_mode) { + switch (button) { + case BUTTON_A: + bluetooth_handle_updown(sdata->pos, 1); + break; + case BUTTON_B: + bluetooth_handle_updown(sdata->pos, -1); + break; + case BUTTON_C: + sdata->pos++; + sdata->pos %= 2; + break; + case BUTTON_F: + bluetooth_screen.set_mode = FALSE; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + } else { + switch (button) { + case BUTTON_F: + bluetooth_screen.set_mode = TRUE; + break; + default: + return EVENT_RET_UNHANDLED; + break; + } + } + + draw_bluetooth_screen(sdata); + + return EVENT_RET_HANDLED; +} + +event_ret_t bluetooth_screen_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + bluetooth_screen.pos = 0; + bluetooth_screen.bt_en = (hal_bluetooth_get_state() > 0); + draw_bluetooth_screen(&bluetooth_screen); + hal_enable_halfsecond_timer(); + break; + case EVENT_SCREEN_DESTROY: + hal_disable_halfsecond_timer(); + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + return handle_bluetooth_buttons(*(watch_button *)data, &bluetooth_screen); + break; + case EVENT_HALF_SEC_TIMER: + if (bluetooth_screen.set_mode) { + if (bluetooth_screen.on) + bluetooth_screen.on = FALSE; + else + bluetooth_screen.on = TRUE; + } else + bluetooth_screen.on = TRUE; + draw_bluetooth_screen(&bluetooth_screen); + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_HANDLED; +} + + +/* + * Info Screen + */ +void draw_info_screen(void) +{ + hal_lcd_clear_display(); + + oswald_draw_bitmap(36, 0, info_icon_width, info_icon_height, info_icon_bits); + + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + oswald_write_string(2, 29, FONT_DROID8x12, FALSE, "Oswald"); + oswald_write_string(35, 29, FONT_DROID8x12, FALSE, OSWALD_VERSION); + oswald_write_string(2, 41, FONT_DROID8x12, FALSE, "HAL"); + oswald_write_string(35, 41, FONT_DROID8x12, FALSE, (char *)hal_get_version_string()); + oswald_write_string(2, 53, FONT_DROID8x12, FALSE, "Build"); + oswald_write_string(35, 53, FONT_DROID8x12, FALSE, (char *)hal_get_buildno_string()); + oswald_write_string(2, 65, FONT_DROID8x12, FALSE, "Radio"); + oswald_write_string(35, 65, FONT_DROID8x12, FALSE, (char *)hal_get_radio_version_string()); + + hal_lcd_update_display(); +} + +event_ret_t info_screen_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + draw_info_screen(); + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + break; + default: + return EVENT_RET_UNHANDLED; + break; + }; + return EVENT_RET_UNHANDLED; +} + + +/* + * Messages Screens + */ +typedef struct { + int8_t pos; // marker position + int8_t offset; // offset in msg list +} messages_data_t; +static messages_data_t messages_screen = { + 0, + 0, +}; + +typedef struct { + uint8_t day; + uint8_t month; + uint8_t year; // without century, add +1900 + uint8_t hour; + uint8_t minute; +} msg_timedate_t; + +#define MSG_TYPE_READ 0 +#define MSG_TYPE_NEW 1 +#define MSG_TYPE_END 127 + +typedef struct { + uint8_t type; + msg_timedate_t td; + char *msg; +} message_t; + +uint8_t Msgs = 15; +message_t Msg[] = { + { MSG_TYPE_READ, {9,5,113,0,38}, "Testmessage with more text than fits into the menu." }, + { MSG_TYPE_NEW, {9,5,113,0,39}, "Sitting in the train waiting to arrive." }, + { MSG_TYPE_READ, {9,5,113,0,40}, "People in the train are annoying!" }, + { MSG_TYPE_READ, {9,5,113,0,40}, "Auch auf Deutsch geht das hier und Text können lang sein." }, + { MSG_TYPE_NEW, {8,5,113,0,40}, "Und hier noch eine neue Nachricht, die nun wirklich lang ist, laenger als die anderen." }, + { MSG_TYPE_READ, {9,5,113,0,38}, "Testmessage with more text than fits into the menu." }, + { MSG_TYPE_NEW, {9,5,113,0,39}, "Sitting in the train waiting to arrive." }, + { MSG_TYPE_READ, {9,5,113,0,40}, "People in the train are annoying!" }, + { MSG_TYPE_READ, {9,5,113,0,40}, "Auch auf Deutsch geht das hier und Text können lang sein." }, + { MSG_TYPE_NEW, {8,5,113,0,40}, "Und hier noch eine neue Nachricht, die nun wirklich lang ist, laenger als die anderen." }, + { MSG_TYPE_READ, {9,5,113,0,38}, "Testmessage with more text than fits into the menu." }, + { MSG_TYPE_NEW, {9,5,113,0,39}, "Sitting in the train waiting to arrive." }, + { MSG_TYPE_READ, {9,5,113,0,40}, "People in the train are annoying!" }, + { MSG_TYPE_READ, {9,5,113,0,40}, "Auch auf Deutsch geht das hier und Text können lang sein." }, + { MSG_TYPE_NEW, {8,5,113,0,40}, "Und hier noch eine neue Nachricht, die nun wirklich lang ist, laenger als die anderen." }, + { MSG_TYPE_END, {0,0,0,0,0}, "Exit" }, +}; + +void draw_message_screen(messages_data_t *sdata) +{ + char dstr[32]; + uint8_t strpos, msglen; + uint8_t line; + + hal_lcd_clear_display(); + +#if 0 + oswald_draw_bitmap(81, 6, upbutton_icon_width, upbutton_icon_height, upbutton_icon_bits); + oswald_draw_bitmap(81, 38, downbutton_icon_width, downbutton_icon_height, downbutton_icon_bits); +#endif + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + Msg[sdata->offset + sdata->pos].type = MSG_TYPE_READ; + snprintf(dstr, 19, "#%02d/%02d", sdata->pos + sdata->offset + 1, Msgs); + oswald_write_string(30, 0, FONT_5x7, FALSE, dstr); + oswald_draw_line(0,7,95,7); + + + // here goes the text + msglen = strlen(Msg[sdata->pos+sdata->offset].msg); + strpos=0; + line=0; + while ((strpos < msglen) && (line < 6)) { + strpos += oswald_write_string_length(4, 9+(line*12), 84, FONT_DROID8x12, FALSE, &Msg[sdata->pos+sdata->offset].msg[strpos]); + line++; + } + + + oswald_draw_line(0,87,95,87); + + if (Msg[sdata->offset + sdata->pos].type != MSG_TYPE_END) { + snprintf(dstr, 19, "%c %02d.%02d.%04d,%02d:%02d", (Msg[sdata->pos+sdata->offset].type == MSG_TYPE_NEW) ? '*':' ', Msg[sdata->pos+sdata->offset].td.day, Msg[sdata->pos+sdata->offset].td.month, Msg[sdata->pos+sdata->offset].td.year+1900, Msg[sdata->pos+sdata->offset].td.hour, Msg[sdata->pos+sdata->offset].td.minute); + oswald_write_string(2, 89, FONT_5x7, FALSE, dstr); + } + + hal_lcd_update_display(); +} + +event_ret_t handle_message_screen_buttons(watch_button button, messages_data_t *sdata) +{ + switch (button) { + case BUTTON_A: + break; + case BUTTON_B: + return EVENT_RET_HANDLED; + break; + case BUTTON_C: + // OswaldState.screen->event_func(EVENT_SCREEN_DESTROY, NULL); + OswaldState.screen_id = MESSAGES_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + return EVENT_RET_HANDLED; + break; + default: + break; + } + + return EVENT_RET_UNHANDLED; +} + +event_ret_t message_screen_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: + draw_message_screen(&messages_screen); + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + return handle_message_screen_buttons(*(watch_button *)data, &messages_screen); + break; + default: + break; + }; + return EVENT_RET_UNHANDLED; +} + +void draw_messages_screen(messages_data_t *sdata) +{ + char dstr[32]; + int i; + + hal_lcd_clear_display(); + + // oswald_draw_bitmap(36, 0, Message_icon_width, Message_icon_height, Message_icon_bits); + + oswald_draw_bitmap(81, 6, upbutton_icon_width, upbutton_icon_height, upbutton_icon_bits); + oswald_draw_bitmap(81, 38, downbutton_icon_width, downbutton_icon_height, downbutton_icon_bits); + oswald_draw_bitmap(81, 70, enterbutton_icon_width, enterbutton_icon_height, enterbutton_icon_bits); + + if (Msg[sdata->offset + sdata->pos].type != MSG_TYPE_END) { + snprintf(dstr, 19, "#%02d/%02d", sdata->pos + sdata->offset + 1, Msgs); + oswald_write_string(30, 0, FONT_5x7, FALSE, dstr); + } + oswald_draw_line(0,7,95,7); + + for (i=0; i<6; i++) { + if (Msg[i+sdata->offset].type != MSG_TYPE_END) { + //oswald_write_string_length(4, 9+(i*12), 84, FONT_DROID8x12, (Msg[i+sdata->offset].type == MSG_TYPE_NEW), Msg[i+sdata->offset].msg); + if (Msg[i+sdata->offset].type == MSG_TYPE_NEW) + oswald_write_string_length(4, 9+(i*12), 84, FONT_DROID8x12b, (i+sdata->offset) == (sdata->offset + sdata->pos), Msg[i+sdata->offset].msg); + else + oswald_write_string_length(4, 9+(i*12), 84, FONT_DROID8x12, (i+sdata->offset) == (sdata->offset + sdata->pos), Msg[i+sdata->offset].msg); + } else { + oswald_draw_bitmap(0, 66, leftbutton_icon_width, leftbutton_icon_height, leftbutton_icon_bits); + } + } + + // marker selected msg + oswald_draw_line(1,9,1,81); + oswald_draw_line_ww(1,10+(sdata->pos*12),1,20+(sdata->pos*12),2); + + oswald_draw_line(0,87,95,87); + + if (Msg[sdata->offset + sdata->pos].type != MSG_TYPE_END) { + snprintf(dstr, 19, "%c %02d.%02d.%04d,%02d:%02d", (Msg[sdata->pos+sdata->offset].type == MSG_TYPE_NEW) ? '*':' ', Msg[sdata->pos+sdata->offset].td.day, Msg[sdata->pos+sdata->offset].td.month, Msg[sdata->pos+sdata->offset].td.year+1900, Msg[sdata->pos+sdata->offset].td.hour, Msg[sdata->pos+sdata->offset].td.minute); + oswald_write_string(2, 89, FONT_5x7, FALSE, dstr); + } + + hal_lcd_update_display(); +} + +event_ret_t handle_messages_screen_buttons(watch_button button, messages_data_t *sdata) +{ + switch (button) { + case BUTTON_A: + sdata->pos--; + if (sdata->pos < 0) { + if (sdata->offset > 0) { + sdata->pos = 0; + sdata->offset--; + if (sdata->offset < 0) + sdata->offset = 0; + } else { + sdata->pos = 5; + sdata->offset = (Msgs - 5); + if (sdata->offset < 0) + sdata->offset = 0; + } + } + draw_messages_screen(&messages_screen); + return EVENT_RET_HANDLED; + break; + case BUTTON_B: + sdata->pos++; + if (sdata->pos > 5) { + sdata->pos = 5; + sdata->offset++; + if ((sdata->offset + 5) > Msgs) { + sdata->offset = 0; + sdata->pos = 0; + } + } + draw_messages_screen(&messages_screen); + return EVENT_RET_HANDLED; + break; + case BUTTON_C: + if (Msg[sdata->offset + sdata->pos].type == MSG_TYPE_END) + return EVENT_RET_UNHANDLED; + else + // OswaldState.screen->event_func(EVENT_SCREEN_DESTROY, NULL); + OswaldState.screen_id = MESSAGE_SCREEN; + OswaldState.screen = &OswaldScreens[OswaldState.screen_id]; + OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL); + return EVENT_RET_HANDLED; + break; + default: + break; + } + + return EVENT_RET_UNHANDLED; +} + +event_ret_t messages_screen_handle_events(uint16_t event, void *data) +{ + switch (event) { + case EVENT_SCREEN_VISIBLE: +// messages_screen.pos = 0; +// messages_screen.offset = 0; + draw_messages_screen(&messages_screen); + return EVENT_RET_HANDLED; + break; + case EVENT_USER_BUTTONS: + dbg_out("button event %d\n", *(int *)data); + return handle_messages_screen_buttons(*(watch_button *)data, &messages_screen); + break; default: break; }; + return EVENT_RET_UNHANDLED; }