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 }
  86
  87 void accel_handle_events(u16t event, void *data)
  88 {
  89         switch (event) {
  90                 case EVENT_SCREEN_VISIBLE:
  91                         draw_accel_screen(&accel_screen.accdata);
  92                         break;
  93                 case EVENT_ACCEL_UPDATE: {
  94                         accel_data_t *accel_data = (accel_data_t *)data;
  95                         accel_screen.accdata.x = accel_data->x;
  96                         accel_screen.accdata.y = accel_data->y;
  97                         accel_screen.accdata.z = accel_data->z;
  98                         draw_accel_screen(&accel_screen.accdata);
  99                         };
 100                         break;
 101                 case EVENT_USER_BUTTONS:
 102                         dbg_out("button event %d\n", *(int *)data);
 103                         break;
 104                 default:
 105                         break;
 106         };
 107 }
 108
 109
 110 typedef struct {
 111         u8t pos;
 112         boolean on;
 113 } datetime_setup_data_t;
 114 static datetime_setup_data_t dt_setup_screen = {
 115         0,
 116         TRUE
 117 };
 118
 119 void draw_datetime_setup_screen(datetime_setup_data_t *sdata)
 120 {
 121         lcd_clear_display();
 122         SetFont(MetaWatch16);
 123         WriteLcdString(2, 2, "Set");
 124
 125         SetFont(MetaWatchTime);
 126         if ((sdata->pos == 0 && sdata->on) || sdata->pos != 0) {
 127                 WriteLcdCharacter(2, 20, (OswaldClk.hour / 10));
 128                 WriteLcdCharacter(14, 20, (OswaldClk.hour % 10));
 129         }
 130         WriteLcdCharacter(26, 20, TIME_CHARACTER_COLON_INDEX);
 131
 132         if ((sdata->pos == 1 && sdata->on) || sdata->pos != 1) {
 133                 WriteLcdCharacter(31, 20, (OswaldClk.minute / 10));
 134                 WriteLcdCharacter(43, 20, (OswaldClk.minute % 10));
 135         }
 136
 137         WriteLcdCharacter(55, 20, TIME_CHARACTER_COLON_INDEX);
 138
 139         if ((sdata->pos == 2 && sdata->on) || sdata->pos != 2) {
 140                 WriteLcdCharacter(60, 20, (OswaldClk.second / 10));
 141                 WriteLcdCharacter(72, 20, (OswaldClk.second % 10));
 142         }
 143
 144         SetFont(MetaWatch16);
 145         if ((sdata->pos == 3 && sdata->on) || sdata->pos != 3) {
 146                 WriteLcdNumber(2, 45, OswaldClk.day);
 147         }
 148         WriteLcdString(18, 45, ".");
 149         if ((sdata->pos == 4 && sdata->on) || sdata->pos != 4) {
 150                 WriteLcdNumber(22, 45, OswaldClk.month);
 151         }
 152         WriteLcdString(38, 45, ".");
 153         if ((sdata->pos == 5 && sdata->on) || sdata->pos != 5) {
 154                 WriteLcdNumber(42, 45, OswaldClk.year);
 155         }
 156
 157         SetFont(MetaWatch7);
 158         if ((sdata->pos == 6 && sdata->on) || sdata->pos != 6) {
 159                 if (OswaldClk.clk24hr)
 160                         WriteLcdString(2, 66, "x");
 161                 else
 162                         WriteLcdString(2, 66, "_");
 163         }
 164         WriteLcdString(15, 66, "24hr");
 165
 166         if ((sdata->pos == 7 && sdata->on) || sdata->pos != 7) {
 167                 if (OswaldClk.day_first)
 168                         WriteLcdString(2, 79, "x");
 169                 else
 170                         WriteLcdString(2, 79, "_");
 171         }
 172         WriteLcdString(15, 79, "dd.mm.  mm/dd");
 173 }
 174
 175 void datetime_handle_updown(u8t pos, s8t incr)
 176 {
 177         switch (pos) {
 178                 case 0: // hour
 179                         if (OswaldClk.hour == 0 && incr == -1) {
 180                                 OswaldClk.hour = 23;
 181                                 break;
 182                         };
 183                         OswaldClk.hour += incr;
 184                         if (OswaldClk.hour > 23)
 185                                 OswaldClk.hour = 0;
 186                         break;
 187                 case 1: // minute
 188                         if (OswaldClk.minute == 0 && incr == -1) {
 189                                 OswaldClk.minute = 59;
 190                                 break;
 191                         };
 192                         OswaldClk.minute += incr;
 193                         if (OswaldClk.minute > 59)
 194                                 OswaldClk.minute = 0;
 195                         break;
 196                 case 2: // second
 197                         OswaldClk.second = 0;
 198                         break;
 199                 case 3: // day
 200                         if (OswaldClk.day == 1 && incr == -1) {
 201                                 OswaldClk.day = 31;
 202                                 break;
 203                         };
 204                         OswaldClk.day += incr;
 205                         if (OswaldClk.day > 31)
 206                                 OswaldClk.day = 1;
 207                         break;
 208                 case 4: // month
 209                         if (OswaldClk.month == 1 && incr == -1) {
 210                                 OswaldClk.month = 12;
 211                                 break;
 212                         };
 213                         OswaldClk.month += incr;
 214                         if (OswaldClk.month > 12)
 215                                 OswaldClk.month = 1;
 216                         break;
 217                 case 5: // year
 218                         OswaldClk.year += incr;
 219                         break;
 220                 case 6: // 24hr / 12hr
 221                         if (OswaldClk.clk24hr)
 222                                 OswaldClk.clk24hr = FALSE;
 223                         else
 224                                 OswaldClk.clk24hr = TRUE;
 225                         break;
 226                 case 7: // dd.mm. / mm/dd
 227                         if (OswaldClk.day_first)
 228                                 OswaldClk.day_first = FALSE;
 229                         else
 230                                 OswaldClk.day_first = TRUE;
 231                         break;
 232                 default:
 233                         break;
 234         };
 235 }
 236
 237 void handle_setup_datetime_buttons(watch_button button, datetime_setup_data_t *sdata)
 238 {
 239         switch (button) {
 240                 case BUTTON_A:
 241                         datetime_handle_updown(sdata->pos, 1);
 242                         break;
 243                 case BUTTON_B:
 244                         datetime_handle_updown(sdata->pos, -1);
 245                         break;
 246                 case BUTTON_D:
 247                         sdata->pos++;
 248                         sdata->pos %= 8;
 249                         break;
 250                 default:
 251                         break;
 252         }
 253         draw_datetime_setup_screen(sdata);
 254 }
 255
 256 void datetime_setup_events(u16t event, void *data)
 257 {
 258         switch (event) {
 259                 case EVENT_SCREEN_VISIBLE:
 260                         draw_datetime_setup_screen(&dt_setup_screen);
 261                         enable_halfsecond_timer();
 262                         break;
 263                 case EVENT_SCREEN_DESTROY:
 264                         disable_halfsecond_timer();
 265                         break;
 266                 case EVENT_USER_BUTTONS:
 267                         dbg_out("button event %d\n", *(int *)data);
 268                         handle_setup_datetime_buttons(*(watch_button *)data, &dt_setup_screen);
 269                         break;
 270                 case EVENT_HALF_SEC_TIMER:
 271                         if (dt_setup_screen.on)
 272                                 dt_setup_screen.on = FALSE;
 273                         else
 274                                 dt_setup_screen.on = TRUE;
 275                         draw_datetime_setup_screen(&dt_setup_screen);
 276                         break;
 277                 default:
 278                         break;
 279         };
 280 }
 281
 282
 283 typedef struct {
 284         u8t menu_pos;
 285 } test_menu_t;
 286 static test_menu_t test_menu = { 0 };
 287
 288 void draw_menu_test_screen(void)
 289 {
 290         lcd_clear_display();
 291         SetFont(MetaWatch16);
 292         WriteLcdString(2, 2, "Menu");
 293         SetFont(MetaWatch7);
 294         WriteLcdString(2, 20, "Item 1");
 295         WriteLcdString(2, 29, "Item 2");
 296         WriteLcdString(2, 38, "Item 3");
 297         WriteLcdString(2, 47, "Item 4");
 298         WriteLcdString(2, 56, "Item 5");
 299
 300         WriteLcdString(50, 20+(9*test_menu.menu_pos), "*");
 301 }
 302
 303 static void handle_menu_user_buttons(watch_button button)
 304 {
 305         switch (button) {
 306                 case BUTTON_A:
 307                         test_menu.menu_pos--;
 308                         test_menu.menu_pos%=5;
 309                         break;
 310                 case BUTTON_B:
 311                         test_menu.menu_pos++;
 312                         test_menu.menu_pos%=5;
 313                         break;
 314                 default:
 315                         break;
 316         }
 317         draw_menu_test_screen();
 318 }
 319
 320 void test_menu_handle_events(u16t event, void *data)
 321 {
 322         switch (event) {
 323                 case EVENT_USER_BUTTONS:
 324                         dbg_out("button event %d\n", *(int *)data);
 325                         handle_menu_user_buttons(*(watch_button *)data);
 326                         break;
 327                 case EVENT_SCREEN_VISIBLE:
 328                         test_menu.menu_pos = 0;
 329                         draw_menu_test_screen();
 330                         break;
 331                 default:
 332                         break;
 333         };
 334 }
 335