Oh boy... lots of changes, too many to describe

[oswald.git] / ui / oswald_screens.c

diff --git a/ui/oswald_screens.c b/ui/oswald_screens.c
index cbe29564a5b439b0e2d6cd4fd3b16702769c2c84..c09958fd2c6635d99f2486f9e3e917dabb326e5e 100644 (file)
--- a/ui/oswald_screens.c
+++ b/ui/oswald_screens.c
@@ -1,8 +1,11 @@
+#include <stdio.h>
+

 #include "oswald.h"
 #include "oswald_main.h"
 #include "oswald_watch_faces.h"
 #include "Fonts.h"
 #include "LcdDisplay.h"
 #include "oswald.h"
 #include "oswald_main.h"
 #include "oswald_watch_faces.h"
 #include "Fonts.h"
 #include "LcdDisplay.h"

+#include "oswald_hal.h"

 
 #include "oswald_screens.h"
 
 
 #include "oswald_screens.h"
 


@@ -14,7 +17,7 @@ typedef struct {
 } idle_data_t;
 static idle_data_t idle_screen = {
        DrawLcdDigitalClock,
 } idle_data_t;
 static idle_data_t idle_screen = {
        DrawLcdDigitalClock,

-       FALSE,
+       TRUE,

        FALSE,
 };
  
        FALSE,
 };
  


@@ -36,7 +39,7 @@ void idle_handle_user_buttons(watch_button button)
                                idle_screen.screendraw_func = DrawLcdAnaClock;
                        };
                        break;
                                idle_screen.screendraw_func = DrawLcdAnaClock;
                        };
                        break;

-               case BUTTON_D:
+               case BUTTON_F:

                        OswaldState.screen_id = DATETIME_SETTING_SCREEN;
                        OswaldState.screen = &OswaldScreens[OswaldState.screen_id];
                        OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL);
                        OswaldState.screen_id = DATETIME_SETTING_SCREEN;
                        OswaldState.screen = &OswaldScreens[OswaldState.screen_id];
                        OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL);


@@ -74,7 +77,7 @@ static accelscreen_data_t accel_screen = {
 
 void draw_accel_screen(accel_data_t *accel_data)
 {
 
 void draw_accel_screen(accel_data_t *accel_data)
 {

-       lcd_clear_display();
+       hal_lcd_clear_display();

        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "X:");
        WriteLcdNumber(20, 2, accel_data->x);
        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "X:");
        WriteLcdNumber(20, 2, accel_data->x);


@@ -82,7 +85,7 @@ void draw_accel_screen(accel_data_t *accel_data)
        WriteLcdNumber(20, 18, accel_data->y);
        WriteLcdString(2, 34, "Z:");
        WriteLcdNumber(20, 34, accel_data->z);
        WriteLcdNumber(20, 18, accel_data->y);
        WriteLcdString(2, 34, "Z:");
        WriteLcdNumber(20, 34, accel_data->z);

-       lcd_update_display();
+       hal_lcd_update_display();

 }
 
 void accel_handle_events(u16t event, void *data)
 }
 
 void accel_handle_events(u16t event, void *data)


@@ -119,7 +122,7 @@ static datetime_setup_data_t dt_setup_screen = {
 
 void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
 {
 
 void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
 {

-       lcd_clear_display();
+       hal_lcd_clear_display();

        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "Set");
 
        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "Set");
 


@@ -172,7 +175,7 @@ void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
        }
        WriteLcdString(15, 79, "dd.mm.  mm/dd");
 
        }
        WriteLcdString(15, 79, "dd.mm.  mm/dd");
 

-       lcd_update_display();
+       hal_lcd_update_display();

 }
 
 void datetime_handle_updown(u8t pos, s8t incr)
 }
 
 void datetime_handle_updown(u8t pos, s8t incr)


@@ -235,6 +238,10 @@ void datetime_handle_updown(u8t pos, s8t incr)
                default:
                        break;
        };
                default:
                        break;
        };

+       if (pos == 2)
+               hal_set_rtc(&OswaldClk, TRUE);
+       else
+               hal_set_rtc(&OswaldClk, FALSE);

 }
 
 void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata)
 }
 
 void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata)


@@ -246,7 +253,7 @@ void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *s
                case BUTTON_B:
                        datetime_handle_updown(sdata->pos, -1);
                        break;
                case BUTTON_B:
                        datetime_handle_updown(sdata->pos, -1);
                        break;

-               case BUTTON_D:
+               case BUTTON_F:

                        sdata->pos++;
                        sdata->pos %= 8;
                        break;
                        sdata->pos++;
                        sdata->pos %= 8;
                        break;


@@ -260,11 +267,12 @@ void datetime_setup_events(u16t event, void *data)
 {
        switch (event) {
                case EVENT_SCREEN_VISIBLE:
 {
        switch (event) {
                case EVENT_SCREEN_VISIBLE:

+                       dt_setup_screen.pos = 0;

                        draw_datetime_setup_screen(&dt_setup_screen);
                        draw_datetime_setup_screen(&dt_setup_screen);

-                       enable_halfsecond_timer();
+                       hal_enable_halfsecond_timer();

                        break;
                case EVENT_SCREEN_DESTROY:
                        break;
                case EVENT_SCREEN_DESTROY:

-                       disable_halfsecond_timer();
+                       hal_disable_halfsecond_timer();

                        break;
                case EVENT_USER_BUTTONS:
                        dbg_out("button event %d\n", *(int *)data);
                        break;
                case EVENT_USER_BUTTONS:
                        dbg_out("button event %d\n", *(int *)data);


@@ -282,6 +290,172 @@ void datetime_setup_events(u16t event, void *data)
        };
 }
 
        };
 }
 

+typedef struct {
+       u8t pos;
+       boolean on;
+} alarm_setup_data_t;
+static alarm_setup_data_t alarm_setup_screen = {
+       0,
+       TRUE
+};
+
+void draw_alarm_setup_screen(alarm_setup_data_t *sdata)
+{
+       hal_lcd_clear_display();
+
+       SetFont(MetaWatch16);
+       WriteLcdString(2, 2, "Alarm");
+
+       SetFont(MetaWatchTime);
+       if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
+               WriteLcdCharacter(2, 20, (OswaldAlarm.hour / 10));
+               WriteLcdCharacter(14, 20, (OswaldAlarm.hour % 10));
+       }
+       WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);
+
+       if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
+               WriteLcdCharacter(31, 20, (OswaldAlarm.minute / 10));
+               WriteLcdCharacter(43, 20, (OswaldAlarm.minute % 10));
+       }
+
+       SetFont(MetaWatchMonospaced10);
+       WriteLcdCharacter(3, 45, 'S');
+       WriteLcdCharacter(15, 45, 'M');
+       WriteLcdCharacter(27, 45, 'T');
+       WriteLcdCharacter(39, 45, 'W');
+       WriteLcdCharacter(51, 45, 'T');
+       WriteLcdCharacter(63, 45, 'F');
+       WriteLcdCharacter(75, 45, 'S');
+
+       if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2)
+               WriteLcdCharacter(3, 55, (OswaldAlarm.wday & WDAY_SUNDAY) ? 'x' : '_');
+       if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3)
+               WriteLcdCharacter(15, 55, (OswaldAlarm.wday & WDAY_MONDAY) ? 'x' : '_');
+       if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4)
+               WriteLcdCharacter(27, 55, (OswaldAlarm.wday & WDAY_TUESDAY) ? 'x' : '_');
+       if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5)
+               WriteLcdCharacter(39, 55, (OswaldAlarm.wday & WDAY_WEDNESDAY) ? 'x' : '_');
+       if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6)
+               WriteLcdCharacter(51, 55, (OswaldAlarm.wday & WDAY_THURSDAY) ? 'x' : '_');
+       if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7)
+               WriteLcdCharacter(63, 55, (OswaldAlarm.wday & WDAY_FRIDAY) ? 'x' : '_');
+       if ((sdata->pos == 8 && sdata->on) || sdata->pos != 8)
+               WriteLcdCharacter(75, 55, (OswaldAlarm.wday & WDAY_SATURDAY) ? 'x' : '_');
+
+#if 0
+       SetFont(MetaWatch7);
+       if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) {
+               if (OswaldClk.clk24hr)
+                       WriteLcdString(2, 66, "x");
+               else
+                       WriteLcdString(2, 66, "_");
+       }
+       WriteLcdString(15, 66, "24hr");
+
+       if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) {
+               if (OswaldClk.day_first)
+                       WriteLcdString(2, 79, "x");
+               else
+                       WriteLcdString(2, 79, "_");
+       }
+       WriteLcdString(15, 79, "dd.mm.  mm/dd");
+#endif
+       hal_lcd_update_display();
+}
+
+void alarm_handle_updown(u8t pos, s8t 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;
+       };
+}
+
+void handle_setup_alarm_buttons(watch_button button, alarm_setup_data_t *sdata)
+{
+       switch (button) {
+               case BUTTON_A:
+                       alarm_handle_updown(sdata->pos, 1);
+                       break;
+               case BUTTON_B:
+                       alarm_handle_updown(sdata->pos, -1);
+                       break;
+               case BUTTON_F:
+                       sdata->pos++;
+                       sdata->pos %= 9;
+                       break;
+               default:
+                       break;
+       }
+       draw_alarm_setup_screen(sdata);
+}
+
+void alarm_setup_events(u16t event, void *data)
+{
+       switch (event) {
+               case EVENT_SCREEN_VISIBLE:
+                       alarm_setup_screen.pos = 0;
+                       draw_alarm_setup_screen(&alarm_setup_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);
+                       handle_setup_alarm_buttons(*(watch_button *)data, &alarm_setup_screen);
+                       break;
+               case EVENT_HALF_SEC_TIMER:
+                       if (alarm_setup_screen.on)
+                               alarm_setup_screen.on = FALSE;
+                       else
+                               alarm_setup_screen.on = TRUE;
+                       draw_alarm_setup_screen(&alarm_setup_screen);
+                       break;
+               default:
+                       break;
+       };
+}
+

 
 typedef struct {
        u8t menu_pos;
 
 typedef struct {
        u8t menu_pos;


@@ -290,7 +464,7 @@ static test_menu_t test_menu = { 0 };
 
 void draw_menu_test_screen(void)
 {
 
 void draw_menu_test_screen(void)
 {

-       lcd_clear_display();
+       hal_lcd_clear_display();

        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "Menu");
        SetFont(MetaWatch7);
        SetFont(MetaWatch16);
        WriteLcdString(2, 2, "Menu");
        SetFont(MetaWatch7);


@@ -301,7 +475,7 @@ void draw_menu_test_screen(void)
        WriteLcdString(2, 56, "Item 5");
 
        WriteLcdString(50, 20+(9*test_menu.menu_pos), "*");
        WriteLcdString(2, 56, "Item 5");
 
        WriteLcdString(50, 20+(9*test_menu.menu_pos), "*");

-       lcd_update_display();
+       hal_lcd_update_display();

 }
 
 static void handle_menu_user_buttons(watch_button button)
 }
 
 static void handle_menu_user_buttons(watch_button button)


@@ -354,8 +528,10 @@ static stopwatch_data_t stopwatch_screen = { 0, 0, 0, 0, 0, 0, 0, 0, FALSE };
 
 static void update_stop_watch_screen(stopwatch_data_t *sdata)
 {
 
 static void update_stop_watch_screen(stopwatch_data_t *sdata)
 {

+       char tstr[16];

        SetFont(MetaWatchMonospaced10);
 
        SetFont(MetaWatchMonospaced10);
 

+#if 0

        WriteLcdNumber(0, 30, sdata->hr);
        WriteLcdCharacter(14, 30, ':');
        WriteLcdNumber(19, 30, sdata->min);
        WriteLcdNumber(0, 30, sdata->hr);
        WriteLcdCharacter(14, 30, ':');
        WriteLcdNumber(19, 30, sdata->min);


@@ -371,8 +547,14 @@ static void update_stop_watch_screen(stopwatch_data_t *sdata)
        WriteLcdNumber(38, 50, sdata->lapse_sec);
        WriteLcdCharacter(52, 50, '.');
        WriteLcdNumber(57, 50, sdata->lapse_csec / 10);
        WriteLcdNumber(38, 50, sdata->lapse_sec);
        WriteLcdCharacter(52, 50, '.');
        WriteLcdNumber(57, 50, sdata->lapse_csec / 10);

-
-       lcd_update_display();
+#else
+       snprintf(tstr, 16, "%02d:%02d:%02d.%1d", sdata->hr, sdata->min, sdata->sec, sdata->csec / 10);
+       WriteLcdString(0, 30, tstr);
+       snprintf(tstr, 16, "%02d:%02d:%02d.%02d", sdata->lapse_hr, sdata->lapse_min, sdata->lapse_sec, sdata->lapse_csec);
+       WriteLcdString(0, 50, tstr);
+#endif
+
+       hal_lcd_update_display();

 }
 
 static void draw_stop_watch_screen(stopwatch_data_t *sdata)
 }
 
 static void draw_stop_watch_screen(stopwatch_data_t *sdata)


@@ -388,10 +570,10 @@ static void handle_stop_watch_buttons(watch_button button)
        switch (button) {
                case BUTTON_A: // start/stop
                        if (stopwatch_screen.running) {
        switch (button) {
                case BUTTON_A: // start/stop
                        if (stopwatch_screen.running) {

-                               disable_centisecond_timer();
+                               hal_disable_centisecond_timer();

                                stopwatch_screen.running = FALSE;
                        } else {
                                stopwatch_screen.running = FALSE;
                        } else {

-                               enable_centisecond_timer();
+                               hal_enable_centisecond_timer();

                                stopwatch_screen.running = TRUE;
                        }
                        break;
                                stopwatch_screen.running = TRUE;
                        }
                        break;


@@ -401,7 +583,7 @@ static void handle_stop_watch_buttons(watch_button button)
                        stopwatch_screen.lapse_sec = stopwatch_screen.sec;
                        stopwatch_screen.lapse_csec = stopwatch_screen.csec;
                        break;
                        stopwatch_screen.lapse_sec = stopwatch_screen.sec;
                        stopwatch_screen.lapse_csec = stopwatch_screen.csec;
                        break;

-               case BUTTON_D: // reset
+               case BUTTON_F: // reset

                        stopwatch_screen.hr = 0;
                        stopwatch_screen.min = 0;
                        stopwatch_screen.sec = 0;
                        stopwatch_screen.hr = 0;
                        stopwatch_screen.min = 0;
                        stopwatch_screen.sec = 0;


@@ -425,11 +607,11 @@ void stop_watch_handle_events(u16t event, void *data)
                        update_stop_watch_screen(&stopwatch_screen);
                        break;
                case EVENT_SCREEN_VISIBLE:
                        update_stop_watch_screen(&stopwatch_screen);
                        break;
                case EVENT_SCREEN_VISIBLE:

-                       lcd_clear_display();
+                       hal_lcd_clear_display();

                        draw_stop_watch_screen(&stopwatch_screen);
                        break;
                case EVENT_SCREEN_DESTROY:
                        draw_stop_watch_screen(&stopwatch_screen);
                        break;
                case EVENT_SCREEN_DESTROY:

-                       disable_centisecond_timer();
+                       hal_disable_centisecond_timer();

                        stopwatch_screen.running = FALSE;
                        break;
                case EVENT_CS_TIMER:
                        stopwatch_screen.running = FALSE;
                        break;
                case EVENT_CS_TIMER:


@@ -456,3 +638,42 @@ void stop_watch_handle_events(u16t event, void *data)
                        break;
        };
 }
                        break;
        };
 }

+
+
+void draw_alarm_screen(void)
+{
+       hal_lcd_clear_display();
+
+       SetFont(MetaWatch16);
+       WriteLcdString(2, 2, "ALARM !");
+
+       hal_lcd_update_display();
+}
+
+void alarm_handle_events(u16t event, void *data)
+{
+       switch (event) {
+               case EVENT_SCREEN_VISIBLE:
+                       draw_alarm_screen();
+                       hal_enable_halfsecond_timer();
+                       hal_vibration_set_state(TRUE);
+                       break;
+               case EVENT_SCREEN_DESTROY:
+                       hal_disable_halfsecond_timer();
+                       hal_lcd_set_backlight(FALSE);
+                       hal_vibration_set_state(FALSE);
+                       break;
+               case EVENT_USER_BUTTONS:
+                       dbg_out("button event %d\n", *(int *)data);
+                       // hal_lcd_set_backlight(FALSE);
+                       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");
+                       break;
+               default:
+                       break;
+       };
+}
+