]> git.karo-electronics.de Git - oswald.git/blobdiff - ui/oswald_screens.c
Countless fixes and enhancements
[oswald.git] / ui / oswald_screens.c
index 7790b70b1110d7ae8b91582376d4f178fb9f660e..171d7b6d22ae244aa384e418b0d626144829b059 100644 (file)
@@ -1,12 +1,14 @@
 #include "oswald.h"
+#include "oswald_main.h"
 #include "oswald_watch_faces.h"
 #include "Fonts.h"
 #include "LcdDisplay.h"
 
 #include "oswald_screens.h"
 
+
 typedef struct {
-       void (*screendraw_func)(boolean shoq_seconds);
+       void (*screendraw_func)(boolean show_seconds);
        boolean show_seconds;
        boolean analogue;
 } idle_data_t;
@@ -19,13 +21,13 @@ static idle_data_t idle_screen = {
 void idle_handle_user_buttons(watch_button button)
 {
        switch (button) {
-               case BUTTON_D:
+               case BUTTON_A:
                        if (idle_screen.show_seconds)
                                idle_screen.show_seconds = FALSE;
                        else
                                idle_screen.show_seconds = TRUE;
                        break;
-               case BUTTON_E:
+               case BUTTON_B:
                        if (idle_screen.analogue == TRUE) {
                                idle_screen.analogue = FALSE;
                                idle_screen.screendraw_func = DrawLcdDigitalClock;
@@ -34,6 +36,12 @@ void idle_handle_user_buttons(watch_button button)
                                idle_screen.screendraw_func = DrawLcdAnaClock;
                        };
                        break;
+               case BUTTON_D:
+                       OswaldState.screen_id = DATETIME_SETTING_SCREEN;
+                       OswaldState.screen = &OswaldScreens[OswaldState.screen_id];
+                       OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL);
+                       return;
+                       break;
                default:
                        break;
        };
@@ -57,23 +65,38 @@ void idle_handle_events(u16t event, void *data)
 }
 
 
-void draw_accel_screen(void)
+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, "X:");
-       WriteLcdString(20, 2, "123");
-       WriteLcdString(2, 18, "Z:");
-       WriteLcdString(20, 18, "123");
-       WriteLcdString(2, 34, "Y:");
-       WriteLcdString(20, 34, "123");
+       WriteLcdNumber(20, 2, accel_data->x);
+       WriteLcdString(2, 18, "Y:");
+       WriteLcdNumber(20, 18, accel_data->y);
+       WriteLcdString(2, 34, "Z:");
+       WriteLcdNumber(20, 34, accel_data->z);
 }
 
 void accel_handle_events(u16t event, void *data)
 {
        switch (event) {
                case EVENT_SCREEN_VISIBLE:
-                       draw_accel_screen();
+                       draw_accel_screen(&accel_screen.accdata);
+                       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);
+                       };
                        break;
                case EVENT_USER_BUTTONS:
                        dbg_out("button event %d\n", *(int *)data);
@@ -84,24 +107,172 @@ void accel_handle_events(u16t event, void *data)
 }
 
 
-void draw_datetime_setup_screen(void)
+typedef struct {
+       u8t pos;
+       boolean on;
+} datetime_setup_data_t;
+static datetime_setup_data_t dt_setup_screen = {
+       0,
+       TRUE
+};
+
+void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
 {
        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");
+       WriteLcdString(2, 2, "Set");
+
+       SetFont(MetaWatchTime);
+       if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
+               WriteLcdCharacter(2, 20, (OswaldClk.hour / 10));
+               WriteLcdCharacter(14, 20, (OswaldClk.hour % 10));
+       }
+       WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);
+
+       if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
+               WriteLcdCharacter(31, 20, (OswaldClk.minute / 10));
+               WriteLcdCharacter(43, 20, (OswaldClk.minute % 10));
+       }
+
+       WriteLcdCharacter(55, 20, TIME_CHARACTER_COLON_INDEX);
+
+       if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) {
+               WriteLcdCharacter(60, 20, (OswaldClk.second / 10));
+               WriteLcdCharacter(72, 20, (OswaldClk.second % 10));
+       }
+
+       SetFont(MetaWatch16);
+       if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) {
+               WriteLcdNumber(2, 45, OswaldClk.day);
+       }
+       WriteLcdString(18, 45, ".");
+       if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) {
+               WriteLcdNumber(22, 45, OswaldClk.month);
+       }
+       WriteLcdString(38, 45, ".");
+       if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) {
+               WriteLcdNumber(42, 45, OswaldClk.year);
+       }
+
+       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");
+}
+
+void datetime_handle_updown(u8t pos, s8t 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;
+       };
+}
+
+void 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_D:
+                       sdata->pos++;
+                       sdata->pos %= 8;
+                       break;
+               default:
+                       break;
+       }
+       draw_datetime_setup_screen(sdata);
 }
 
 void datetime_setup_events(u16t event, void *data)
 {
        switch (event) {
                case EVENT_SCREEN_VISIBLE:
-                       draw_datetime_setup_screen();
+                       draw_datetime_setup_screen(&dt_setup_screen);
+                       enable_halfsecond_timer();
+                       break;
+               case EVENT_SCREEN_DESTROY:
+                       disable_halfsecond_timer();
                        break;
                case EVENT_USER_BUTTONS:
                        dbg_out("button event %d\n", *(int *)data);
+                       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);
                        break;
                default:
                        break;