ui/oswald_screens.c

   1 #include "oswald.h"
   2 #include "oswald_main.h"
   3 #include "oswald_watch_faces.h"
   4 #include "Fonts.h"
   5 #include "LcdDisplay.h"
   6
   7 #include "oswald_screens.h"
   8
   9
  10 typedef struct {
  11         void (*screendraw_func)(boolean show_seconds);
  12         boolean show_seconds;
  13         boolean analogue;
  14 } idle_data_t;
  15 static idle_data_t idle_screen = {
  16         DrawLcdDigitalClock,
  17         FALSE,
  18         FALSE,
  19 };
  20
  21 void idle_handle_user_buttons(watch_button button)
  22 {
  23         switch (button) {
  24                 case BUTTON_A:
  25                         if (idle_screen.show_seconds)
  26                                 idle_screen.show_seconds = FALSE;
  27                         else
  28                                 idle_screen.show_seconds = TRUE;
  29                         break;
  30                 case BUTTON_B:
  31                         if (idle_screen.analogue == TRUE) {
  32                                 idle_screen.analogue = FALSE;
  33                                 idle_screen.screendraw_func = DrawLcdDigitalClock;
  34                         } else {
  35                                 idle_screen.analogue = TRUE;
  36                                 idle_screen.screendraw_func = DrawLcdAnaClock;
  37                         };
  38                         break;
  39                 case BUTTON_D:
  40                         OswaldState.screen_id = DATETIME_SETTING_SCREEN;
  41                         OswaldState.screen = &OswaldScreens[OswaldState.screen_id];
  42                         OswaldState.screen->event_func(EVENT_SCREEN_VISIBLE, NULL);
  43                         return;
  44                         break;
  45                 default:
  46                         break;
  47         };
  48         idle_screen.screendraw_func(idle_screen.show_seconds);
  49 }
  50
  51 void idle_handle_events(u16t event, void *data)
  52 {
  53         switch (event) {
  54                 case EVENT_ONE_SEC_TIMER:
  55                 case EVENT_SCREEN_VISIBLE:
  56                         idle_screen.screendraw_func(idle_screen.show_seconds);
  57                         break;
  58                 case EVENT_USER_BUTTONS:
  59                         dbg_out("button event %d\n", *(int *)data);
  60                         idle_handle_user_buttons(*(watch_button *)data);
  61                         break;
  62                 default:
  63                         break;
  64         };
  65 }
  66
  67
  68 typedef struct {
  69         accel_data_t accdata;
  70 } accelscreen_data_t;
  71 static accelscreen_data_t accel_screen = {
  72         { 0, 0, 0},
  73 };
  74
  75 void draw_accel_screen(accel_data_t *accel_data)
  76 {
  77         lcd_clear_display();
  78         SetFont(MetaWatch16);
  79         WriteLcdString(2, 2, "X:");
  80         WriteLcdNumber(20, 2, accel_data->x);
  81         WriteLcdString(2, 18, "Y:");
  82         WriteLcdNumber(20, 18, accel_data->y);
  83         WriteLcdString(2, 34, "Z:");
  84         WriteLcdNumber(20, 34, accel_data->z);
  85         lcd_update_display();
  86 }
  87
  88 void accel_handle_events(u16t event, void *data)
  89 {
  90         switch (event) {
  91                 case EVENT_SCREEN_VISIBLE:
  92                         draw_accel_screen(&accel_screen.accdata);
  93                         break;
  94                 case EVENT_ACCEL_UPDATE: {
  95                         accel_data_t *accel_data = (accel_data_t *)data;
  96                         accel_screen.accdata.x = accel_data->x;
  97                         accel_screen.accdata.y = accel_data->y;
  98                         accel_screen.accdata.z = accel_data->z;
  99                         draw_accel_screen(&accel_screen.accdata);
 100                         };
 101                         break;
 102                 case EVENT_USER_BUTTONS:
 103                         dbg_out("button event %d\n", *(int *)data);
 104                         break;
 105                 default:
 106                         break;
 107         };
 108 }
 109
 110
 111 typedef struct {
 112         u8t pos;
 113         boolean on;
 114 } datetime_setup_data_t;
 115 static datetime_setup_data_t dt_setup_screen = {
 116         0,
 117         TRUE
 118 };
 119
 120 void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
 121 {
 122         lcd_clear_display();
 123         SetFont(MetaWatch16);
 124         WriteLcdString(2, 2, "Set");
 125
 126         SetFont(MetaWatchTime);
 127         if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
 128                 WriteLcdCharacter(2, 20, (OswaldClk.hour / 10));
 129                 WriteLcdCharacter(14, 20, (OswaldClk.hour % 10));
 130         }
 131         WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);
 132
 133         if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
 134                 WriteLcdCharacter(31, 20, (OswaldClk.minute / 10));
 135                 WriteLcdCharacter(43, 20, (OswaldClk.minute % 10));
 136         }
 137
 138         WriteLcdCharacter(55, 20, TIME_CHARACTER_COLON_INDEX);
 139
 140         if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) {
 141                 WriteLcdCharacter(60, 20, (OswaldClk.second / 10));
 142                 WriteLcdCharacter(72, 20, (OswaldClk.second % 10));
 143         }
 144
 145         SetFont(MetaWatch16);
 146         if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) {
 147                 WriteLcdNumber(2, 45, OswaldClk.day);
 148         }
 149         WriteLcdString(18, 45, ".");
 150         if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) {
 151                 WriteLcdNumber(22, 45, OswaldClk.month);
 152         }
 153         WriteLcdString(38, 45, ".");
 154         if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) {
 155                 WriteLcdNumber(42, 45, OswaldClk.year);
 156         }
 157
 158         SetFont(MetaWatch7);
 159         if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) {
 160                 if (OswaldClk.clk24hr)
 161                         WriteLcdString(2, 66, "x");
 162                 else
 163                         WriteLcdString(2, 66, "_");
 164         }
 165         WriteLcdString(15, 66, "24hr");
 166
 167         if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) {
 168                 if (OswaldClk.day_first)
 169                         WriteLcdString(2, 79, "x");
 170                 else
 171                         WriteLcdString(2, 79, "_");
 172         }
 173         WriteLcdString(15, 79, "dd.mm.  mm/dd");
 174
 175         lcd_update_display();
 176 }
 177
 178 void datetime_handle_updown(u8t pos, s8t incr)
 179 {
 180         switch (pos) {
 181                 case 0: // hour
 182                         if (OswaldClk.hour == 0 && incr == -1) {
 183                                 OswaldClk.hour = 23;
 184                                 break;
 185                         };
 186                         OswaldClk.hour += incr;
 187                         if (OswaldClk.hour > 23)
 188                                 OswaldClk.hour = 0;
 189                         break;
 190                 case 1: // minute
 191                         if (OswaldClk.minute == 0 && incr == -1) {
 192                                 OswaldClk.minute = 59;
 193                                 break;
 194                         };
 195                         OswaldClk.minute += incr;
 196                         if (OswaldClk.minute > 59)
 197                                 OswaldClk.minute = 0;
 198                         break;
 199                 case 2: // second
 200                         OswaldClk.second = 0;
 201                         break;
 202                 case 3: // day
 203                         if (OswaldClk.day == 1 && incr == -1) {
 204                                 OswaldClk.day = 31;
 205                                 break;
 206                         };
 207                         OswaldClk.day += incr;
 208                         if (OswaldClk.day > 31)
 209                                 OswaldClk.day = 1;
 210                         break;
 211                 case 4: // month
 212                         if (OswaldClk.month == 1 && incr == -1) {
 213                                 OswaldClk.month = 12;
 214                                 break;
 215                         };
 216                         OswaldClk.month += incr;
 217                         if (OswaldClk.month > 12)
 218                                 OswaldClk.month = 1;
 219                         break;
 220                 case 5: // year
 221                         OswaldClk.year += incr;
 222                         break;
 223                 case 6: // 24hr / 12hr
 224                         if (OswaldClk.clk24hr)
 225                                 OswaldClk.clk24hr = FALSE;
 226                         else
 227                                 OswaldClk.clk24hr = TRUE;
 228                         break;
 229                 case 7: // dd.mm. / mm/dd
 230                         if (OswaldClk.day_first)
 231                                 OswaldClk.day_first = FALSE;
 232                         else
 233                                 OswaldClk.day_first = TRUE;
 234                         break;
 235                 default:
 236                         break;
 237         };
 238 }
 239
 240 void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata)
 241 {
 242         switch (button) {
 243                 case BUTTON_A:
 244                         datetime_handle_updown(sdata->pos, 1);
 245                         break;
 246                 case BUTTON_B:
 247                         datetime_handle_updown(sdata->pos, -1);
 248                         break;
 249                 case BUTTON_D:
 250                         sdata->pos++;
 251                         sdata->pos %= 8;
 252                         break;
 253                 default:
 254                         break;
 255         }
 256         draw_datetime_setup_screen(sdata);
 257 }
 258
 259 void datetime_setup_events(u16t event, void *data)
 260 {
 261         switch (event) {
 262                 case EVENT_SCREEN_VISIBLE:
 263                         draw_datetime_setup_screen(&dt_setup_screen);
 264                         enable_halfsecond_timer();
 265                         break;
 266                 case EVENT_SCREEN_DESTROY:
 267                         disable_halfsecond_timer();
 268                         break;
 269                 case EVENT_USER_BUTTONS:
 270                         dbg_out("button event %d\n", *(int *)data);
 271                         handle_setup_datetime_buttons(*(watch_button *)data, &dt_setup_screen);
 272                         break;
 273                 case EVENT_HALF_SEC_TIMER:
 274                         if (dt_setup_screen.on)
 275                                 dt_setup_screen.on = FALSE;
 276                         else
 277                                 dt_setup_screen.on = TRUE;
 278                         draw_datetime_setup_screen(&dt_setup_screen);
 279                         break;
 280                 default:
 281                         break;
 282         };
 283 }
 284
 285
 286 typedef struct {
 287         u8t menu_pos;
 288 } test_menu_t;
 289 static test_menu_t test_menu = { 0 };
 290
 291 void draw_menu_test_screen(void)
 292 {
 293         lcd_clear_display();
 294         SetFont(MetaWatch16);
 295         WriteLcdString(2, 2, "Menu");
 296         SetFont(MetaWatch7);
 297         WriteLcdString(2, 20, "Item 1");
 298         WriteLcdString(2, 29, "Item 2");
 299         WriteLcdString(2, 38, "Item 3");
 300         WriteLcdString(2, 47, "Item 4");
 301         WriteLcdString(2, 56, "Item 5");
 302
 303         WriteLcdString(50, 20+(9*test_menu.menu_pos), "*");
 304         lcd_update_display();
 305 }
 306
 307 static void handle_menu_user_buttons(watch_button button)
 308 {
 309         switch (button) {
 310                 case BUTTON_A:
 311                         test_menu.menu_pos--;
 312                         test_menu.menu_pos%=5;
 313                         break;
 314                 case BUTTON_B:
 315                         test_menu.menu_pos++;
 316                         test_menu.menu_pos%=5;
 317                         break;
 318                 default:
 319                         break;
 320         }
 321         draw_menu_test_screen();
 322 }
 323
 324 void test_menu_handle_events(u16t event, void *data)
 325 {
 326         switch (event) {
 327                 case EVENT_USER_BUTTONS:
 328                         dbg_out("button event %d\n", *(int *)data);
 329                         handle_menu_user_buttons(*(watch_button *)data);
 330                         break;
 331                 case EVENT_SCREEN_VISIBLE:
 332                         test_menu.menu_pos = 0;
 333                         draw_menu_test_screen();
 334                         break;
 335                 default:
 336                         break;
 337         };
 338 }
 339
 340
 341 typedef struct {
 342         u8t hr;
 343         u8t min;
 344         u8t sec;
 345         u8t csec;
 346         u8t lapse_hr;
 347         u8t lapse_min;
 348         u8t lapse_sec;
 349         u8t lapse_csec;
 350         boolean running;
 351 } stopwatch_data_t;
 352 static stopwatch_data_t stopwatch_screen = { 0, 0, 0, 0, 0, 0, 0, 0, FALSE };
 353
 354
 355 static void update_stop_watch_screen(stopwatch_data_t *sdata)
 356 {
 357         SetFont(MetaWatchMonospaced10);
 358
 359         WriteLcdNumber(0, 30, sdata->hr);
 360         WriteLcdCharacter(14, 30, ':');
 361         WriteLcdNumber(19, 30, sdata->min);
 362         WriteLcdCharacter(33, 30, ':');
 363         WriteLcdNumber(38, 30, sdata->sec);
 364         WriteLcdCharacter(52, 30, '.');
 365         WriteLcdNumber(57, 30, sdata->csec / 10);
 366
 367         WriteLcdNumber(0, 50, sdata->lapse_hr);
 368         WriteLcdCharacter(14, 50, ':');
 369         WriteLcdNumber(19, 50, sdata->lapse_min);
 370         WriteLcdCharacter(33, 50, ':');
 371         WriteLcdNumber(38, 50, sdata->lapse_sec);
 372         WriteLcdCharacter(52, 50, '.');
 373         WriteLcdNumber(57, 50, sdata->lapse_csec / 10);
 374
 375         lcd_update_display();
 376 }
 377
 378 static void draw_stop_watch_screen(stopwatch_data_t *sdata)
 379 {
 380         SetFont(MetaWatch16);
 381         WriteLcdString(2, 5, "StopWatch");
 382
 383         update_stop_watch_screen(sdata);
 384 }
 385
 386 static void handle_stop_watch_buttons(watch_button button)
 387 {
 388         switch (button) {
 389                 case BUTTON_A: // start/stop
 390                         if (stopwatch_screen.running) {
 391                                 disable_centisecond_timer();
 392                                 stopwatch_screen.running = FALSE;
 393                         } else {
 394                                 enable_centisecond_timer();
 395                                 stopwatch_screen.running = TRUE;
 396                         }
 397                         break;
 398                 case BUTTON_B: // lapse
 399                         stopwatch_screen.lapse_hr = stopwatch_screen.hr;
 400                         stopwatch_screen.lapse_min = stopwatch_screen.min;
 401                         stopwatch_screen.lapse_sec = stopwatch_screen.sec;
 402                         stopwatch_screen.lapse_csec = stopwatch_screen.csec;
 403                         break;
 404                 case BUTTON_D: // reset
 405                         stopwatch_screen.hr = 0;
 406                         stopwatch_screen.min = 0;
 407                         stopwatch_screen.sec = 0;
 408                         stopwatch_screen.csec = 0;
 409                         stopwatch_screen.lapse_hr = 0;
 410                         stopwatch_screen.lapse_min = 0;
 411                         stopwatch_screen.lapse_sec = 0;
 412                         stopwatch_screen.lapse_csec = 0;
 413                         break;
 414                 default:
 415                         break;
 416         }
 417 }
 418
 419 void stop_watch_handle_events(u16t event, void *data)
 420 {
 421         switch (event) {
 422                 case EVENT_USER_BUTTONS:
 423                         dbg_out("button event %d\n", *(int *)data);
 424                         handle_stop_watch_buttons(*(watch_button *)data);
 425                         update_stop_watch_screen(&stopwatch_screen);
 426                         break;
 427                 case EVENT_SCREEN_VISIBLE:
 428                         lcd_clear_display();
 429                         draw_stop_watch_screen(&stopwatch_screen);
 430                         break;
 431                 case EVENT_SCREEN_DESTROY:
 432                         disable_centisecond_timer();
 433                         stopwatch_screen.running = FALSE;
 434                         break;
 435                 case EVENT_CS_TIMER:
 436                         stopwatch_screen.csec++;
 437                         if (stopwatch_screen.csec > 99) {
 438                                 stopwatch_screen.csec = 0;
 439                                 stopwatch_screen.sec++;
 440                         };
 441                         if (stopwatch_screen.sec > 59) {
 442                                 stopwatch_screen.sec = 0;
 443                                 stopwatch_screen.min++;
 444                         };
 445                         if (stopwatch_screen.min > 59) {
 446                                 stopwatch_screen.min = 0;
 447                                 stopwatch_screen.hr++;
 448                         };
 449                         if (stopwatch_screen.hr > 59) {
 450                                 stopwatch_screen.hr = 0;
 451                         };
 452                         if (stopwatch_screen.csec % 10 == 0)
 453                                 update_stop_watch_screen(&stopwatch_screen);
 454                         break;
 455                 default:
 456                         break;
 457         };
 458 }