ui/oswald-ui.c

   1 #include <stdio.h>
   2 #include <sys/stat.h>
   3 #include <fcntl.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <unistd.h>
   7 #include <string.h>
   8 #include <poll.h>
   9 #include <sys/socket.h>
  10 #include <sys/un.h>
  11 #include <time.h>
  12
  13 #include <gtk/gtk.h>
  14
  15 #include "Fonts.h" // the MetaWatch fonts
  16 #include "oswald.h"
  17 #include "oswald_main.h"
  18
  19 #include "oswald-ui.h"
  20
  21 #define BITMAP_WIDTH    192
  22 #define BITMAP_HEIGHT   192
  23
  24 static oswald_ui *ui_g;
  25
  26 void hal_lcd_set_pixel(gint x, gint y, gboolean state)
  27 {
  28         gint ix, iy;
  29
  30         ix = x*2;
  31         iy = y*2;
  32
  33         gdk_draw_point(GDK_DRAWABLE(ui_g->pixmap), state ? ui_g->darea->style->black_gc : ui_g->darea->style->white_gc, ix, iy);
  34         gdk_draw_point(GDK_DRAWABLE(ui_g->pixmap), state ? ui_g->darea->style->black_gc : ui_g->darea->style->white_gc, ix+1, iy);
  35         gdk_draw_point(GDK_DRAWABLE(ui_g->pixmap), state ? ui_g->darea->style->black_gc : ui_g->darea->style->white_gc, ix, iy+1);
  36         gdk_draw_point(GDK_DRAWABLE(ui_g->pixmap), state ? ui_g->darea->style->black_gc : ui_g->darea->style->white_gc, ix+1, iy+1);
  37
  38 }
  39
  40 /* updates the actual LCD so that drawing becomes visible */
  41 void hal_lcd_update_display(void)
  42 {
  43         gtk_widget_queue_draw(ui_g->darea);
  44 }
  45
  46 void hal_lcd_clear_display(void)
  47 {
  48         gdk_draw_rectangle (ui_g->pixmap,
  49                 ui_g->darea->style->white_gc,
  50                 TRUE,
  51                 0, 0,
  52                 ui_g->darea->allocation.width,
  53                 ui_g->darea->allocation.height);
  54
  55         gtk_widget_queue_draw(ui_g->darea);
  56 }
  57
  58 static bluetooth_state bt_state = BLUETOOTH_OFF;
  59 static boolean bt_visible = FALSE;
  60
  61 bluetooth_state hal_bluetooth_set_state(bluetooth_state state)
  62 {
  63         bt_state = state;
  64         if (bt_state == BLUETOOTH_OFF)
  65                 bt_visible = FALSE;
  66
  67         return bt_state;
  68 }
  69
  70 bluetooth_state hal_bluetooth_get_state(void)
  71 {
  72         return bt_state;
  73 }
  74
  75 uint8_t *hal_bluetooth_get_local_bdaddr(void)
  76 {
  77         static uint8_t local_bdaddr[6] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
  78
  79         return local_bdaddr;
  80 }
  81
  82 void hal_bluetooth_set_visible(boolean visible)
  83 {
  84         bt_visible = visible;
  85 }
  86
  87 boolean hal_bluetooth_get_visible(void)
  88 {
  89         return bt_visible;
  90 }
  91
  92 void hal_bluetooth_send_data(const void *mdat, uint16_t mlen)
  93 {
  94         g_printerr("write comm %d\n", mlen);
  95 }
  96
  97 static gint
  98 configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
  99 {
 100         oswald_ui *ui = (oswald_ui *)user_data;
 101
 102         if (ui->pixmap)
 103                 gdk_pixmap_unref(ui->pixmap);
 104
 105         ui->pixmap = gdk_pixmap_new(widget->window,
 106                 widget->allocation.width,
 107                 widget->allocation.height,
 108                 -1);
 109         gdk_draw_rectangle (ui->pixmap,
 110                 widget->style->white_gc,
 111                 TRUE,
 112                 0, 0,
 113                 widget->allocation.width,
 114                 widget->allocation.height);
 115
 116         return TRUE;
 117 }
 118
 119 static gint
 120 expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
 121 {
 122         oswald_ui *ui = (oswald_ui *)user_data;
 123
 124         gdk_draw_pixmap(widget->window,
 125                 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 126                 ui->pixmap,
 127                 event->area.x, event->area.y,
 128                 event->area.x, event->area.y,
 129                 event->area.width, event->area.height);
 130
 131         return FALSE;
 132 }
 133
 134 void button_A_clicked (GtkButton *button, gpointer user_data)
 135 {
 136         oswald_ui *ui = (oswald_ui *)user_data;
 137
 138         // g_print("Button-A clicked\n");
 139         oswald_handle_button_press(BUTTON_A);
 140 }
 141
 142 void button_B_clicked (GtkButton *button, gpointer user_data)
 143 {
 144         oswald_ui *ui = (oswald_ui *)user_data;
 145
 146         // g_print("Button-B clicked\n");
 147         oswald_handle_button_press(BUTTON_B);
 148 }
 149
 150 void button_C_clicked (GtkButton *button, gpointer user_data)
 151 {
 152         oswald_ui *ui = (oswald_ui *)user_data;
 153
 154         // g_print("Button-C clicked\n");
 155         oswald_handle_button_press(BUTTON_C);
 156 }
 157
 158 void button_D_clicked (GtkButton *button, gpointer user_data)
 159 {
 160         oswald_ui *ui = (oswald_ui *)user_data;
 161
 162         // g_print("Button-D clicked\n");
 163         oswald_handle_button_press(BUTTON_D);
 164 }
 165
 166 void button_E_clicked (GtkButton *button, gpointer user_data)
 167 {
 168         oswald_ui *ui = (oswald_ui *)user_data;
 169
 170         // g_print("Button-E clicked\n");
 171         oswald_handle_button_press(BUTTON_E);
 172 }
 173
 174 void button_F_clicked (GtkButton *button, gpointer user_data)
 175 {
 176         oswald_ui *ui = (oswald_ui *)user_data;
 177
 178         // g_print("Button-F clicked\n");
 179         oswald_handle_button_press(BUTTON_F);
 180 }
 181
 182 gboolean button_F_pr (GtkWidget *widget, GdkEvent *event, gpointer user_data)
 183 {
 184         oswald_ui *ui = (oswald_ui *)user_data;
 185         static gint32 press_time;
 186
 187         GdkEventButton *bev = (GdkEventButton *)event;
 188         if (bev->type == GDK_BUTTON_PRESS) {
 189                 press_time = bev->time;
 190                 return FALSE;
 191         };
 192         if (bev->type == GDK_BUTTON_RELEASE) {
 193                 if (bev->time > (press_time+1000)) {
 194                         g_print("Button-F long press\n");
 195                         return TRUE;
 196                 };
 197         };
 198
 199         return FALSE;
 200 }
 201
 202 void ambientlight_value_changed (GtkRange *range, gpointer  user_data)
 203 {
 204         oswald_ui *ui = (oswald_ui *)user_data;
 205         double val;
 206
 207         val = gtk_range_get_value(range);
 208         oswald_handle_ambientlight_event((u8t) val);
 209 }
 210
 211 void accelX_value_changed (GtkRange *range, gpointer  user_data)
 212 {
 213         oswald_ui *ui = (oswald_ui *)user_data;
 214         double val;
 215
 216         val = gtk_range_get_value(range);
 217         ui->accel_x = (u8t)val;
 218         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 219 }
 220
 221 void accelY_value_changed (GtkRange *range, gpointer  user_data)
 222 {
 223         oswald_ui *ui = (oswald_ui *)user_data;
 224         double val;
 225
 226         val = gtk_range_get_value(range);
 227         ui->accel_y = (u8t)val;
 228         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 229 }
 230
 231 void accelZ_value_changed (GtkRange *range, gpointer  user_data)
 232 {
 233         oswald_ui *ui = (oswald_ui *)user_data;
 234         double val;
 235
 236         val = gtk_range_get_value(range);
 237         ui->accel_z = (u8t)val;
 238         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 239 }
 240
 241 static void create_mainwin(oswald_ui *ui)
 242 {
 243         GtkWidget *mvb, *hb, *vb, *btn, *sc, *l;
 244
 245         ui->pixmap = NULL;
 246
 247         ui->mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 248         // gtk_window_set_default_size (GTK_WINDOW (ui->mainwin), 440, 240);
 249         g_signal_connect(G_OBJECT(ui->mainwin), "destroy", gtk_main_quit, NULL);
 250
 251         mvb = gtk_vbox_new(FALSE, 5);
 252         gtk_container_add(GTK_CONTAINER(ui->mainwin), mvb);
 253
 254         hb = gtk_hbox_new(FALSE, 5);
 255         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 256
 257         vb = gtk_vbox_new(FALSE, 5);
 258         gtk_box_pack_start (GTK_BOX(hb), vb, FALSE, FALSE, 5);
 259
 260         btn = gtk_button_new_with_label(" F ");
 261         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 262         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_F_clicked), ui);
 263         g_signal_connect(G_OBJECT(btn), "button-press-event", G_CALLBACK(button_F_pr), ui);
 264         g_signal_connect(G_OBJECT(btn), "button-release-event", G_CALLBACK(button_F_pr), ui);
 265
 266         btn = gtk_button_new_with_label(" E ");
 267         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 268         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_E_clicked), ui);
 269
 270         btn = gtk_button_new_with_label(" D ");
 271         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 272         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_D_clicked), ui);
 273
 274         ui->darea = gtk_drawing_area_new ();
 275         gtk_box_pack_start (GTK_BOX(hb), GTK_WIDGET(ui->darea), FALSE, FALSE, 5);
 276         gtk_drawing_area_size (GTK_DRAWING_AREA(ui->darea), BITMAP_WIDTH, BITMAP_HEIGHT);
 277
 278         gtk_signal_connect (GTK_OBJECT (ui->darea), "expose_event", (GtkSignalFunc) expose_event, ui);
 279         gtk_signal_connect (GTK_OBJECT (ui->darea), "configure_event", (GtkSignalFunc) configure_event, ui);
 280         // gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event", (GtkSignalFunc) motion_notify_event, ui);
 281         // gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event", (GtkSignalFunc) button_press_event, ui);
 282
 283         gtk_widget_set_events (GTK_WIDGET(ui->darea), GDK_EXPOSURE_MASK
 284                 | GDK_LEAVE_NOTIFY_MASK
 285                 | GDK_BUTTON_PRESS_MASK
 286                 | GDK_POINTER_MOTION_MASK
 287                 | GDK_POINTER_MOTION_HINT_MASK);
 288
 289         vb = gtk_vbox_new(FALSE, 5);
 290         gtk_box_pack_start (GTK_BOX(hb), vb, FALSE, FALSE, 5);
 291
 292         btn = gtk_button_new_with_label(" A ");
 293         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 294         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_A_clicked), ui);
 295
 296         btn = gtk_button_new_with_label(" B ");
 297         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 298         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_B_clicked), ui);
 299
 300         btn = gtk_button_new_with_label(" C ");
 301         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 302         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_C_clicked), ui);
 303
 304         // ambient light sensor
 305         sc = gtk_vscale_new_with_range (0, 255, 1);
 306         gtk_box_pack_start (GTK_BOX(hb), sc, FALSE, FALSE, 5);
 307         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(ambientlight_value_changed), ui);
 308
 309         hb = gtk_hbox_new(FALSE, 0);
 310         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 311
 312         l = gtk_label_new("X:");
 313         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 314         sc = gtk_hscale_new_with_range (0, 255, 1);
 315         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 316         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelX_value_changed), ui);
 317
 318         l = gtk_label_new("Y:");
 319         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 320         sc = gtk_hscale_new_with_range (0, 255, 1);
 321         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 322         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelY_value_changed), ui);
 323
 324         l = gtk_label_new("Z:");
 325         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 326         sc = gtk_hscale_new_with_range (0, 255, 1);
 327         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 328         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelZ_value_changed), ui);
 329
 330         gtk_widget_show_all(ui->mainwin);
 331 }
 332
 333 static gboolean one_second_tmo_handler (gpointer userdata)
 334 {
 335         oswald_ui *ui = (oswald_ui *)userdata;
 336
 337         oswald_one_second_tick();
 338
 339         return TRUE;
 340 }
 341
 342 static gboolean app_idle_handler (gpointer user_data)
 343 {
 344         g_print("i");
 345         if (OswaldState.pending_idle) {
 346                 // call Oswald's idle function
 347                 return TRUE;
 348         };
 349         return FALSE;
 350 }
 351
 352 static gboolean centisecond_tmo_handler (gpointer userdata)
 353 {
 354         oswald_ui *ui = (oswald_ui *)userdata;
 355
 356         if (ui->centisecond_active)
 357                 oswald_centisecond_tick();
 358         else
 359                 return FALSE;
 360
 361         return TRUE;
 362 }
 363
 364 void hal_enable_centisecond_timer(void)
 365 {
 366         ui_g->centisecond_active = TRUE;
 367         g_timeout_add(10, centisecond_tmo_handler, ui_g);
 368 }
 369
 370 void hal_disable_centisecond_timer(void)
 371 {
 372         ui_g->centisecond_active = FALSE;
 373 }
 374
 375 static gboolean halfsecond_tmo_handler (gpointer userdata)
 376 {
 377         oswald_ui *ui = (oswald_ui *)userdata;
 378
 379         if (ui->halfsecond_active)
 380                 oswald_halfsecond_tick();
 381         else
 382                 return FALSE;
 383
 384         return TRUE;
 385 }
 386
 387 void hal_enable_halfsecond_timer(void)
 388 {
 389         ui_g->halfsecond_active = TRUE;
 390         g_timeout_add(500, halfsecond_tmo_handler, ui_g);
 391 }
 392
 393 void hal_disable_halfsecond_timer(void)
 394 {
 395         ui_g->halfsecond_active = FALSE;
 396 }
 397
 398 void hal_get_rtc(clock_state *rtc)
 399 {
 400         time_t mt;
 401         struct tm mtime;
 402
 403         mt = time(NULL);
 404         localtime_r(&mt, &mtime);
 405
 406         rtc->hour = mtime.tm_hour;
 407         rtc->minute = mtime.tm_min;
 408         rtc->second = mtime.tm_sec;
 409         rtc->day = mtime.tm_mday;
 410         rtc->month = (mtime.tm_mon + 1);
 411         rtc->year = (mtime.tm_year + 1900);
 412 }
 413
 414 void hal_set_rtc(const clock_state *rtc, boolean set_set)
 415 {
 416 }
 417
 418 void hal_get_power_state(power_state *pwr)
 419 {
 420 }
 421
 422 static boolean BacklightState = FALSE;
 423
 424 /* sets the backlight on/off, on=TRUE, off=FALSE */
 425 void hal_lcd_set_backlight(boolean state)
 426 {
 427         g_print("turn LCD backlight %s\n", state ? "on" : "off");
 428         BacklightState = state;
 429 }
 430
 431 boolean hal_lcd_get_backlight(void)
 432 {
 433         return BacklightState;
 434 }
 435
 436
 437 /* sets the vibration motor on/off, on=TRUE, off=FALSE */
 438 void hal_vibration_set_state(boolean state)
 439 {
 440 }
 441
 442 boolean hal_vibration_get_state(void)
 443 {
 444         return FALSE;
 445 }
 446
 447
 448 int main(int argc , char ** argv)
 449 {
 450         oswald_ui ui;
 451         time_t mt;
 452         struct tm mtime;
 453
 454         ui_g = &ui;
 455
 456         ui.accel_x = 0;
 457         ui.accel_y = 0;
 458         ui.accel_z = 0;
 459         ui.halfsecond_active = FALSE;
 460         ui.centisecond_active = FALSE;
 461
 462         mt = time(NULL);
 463         localtime_r(&mt, &mtime);
 464
 465         gtk_init (&argc, &argv);
 466
 467         create_mainwin(&ui);
 468         gtk_widget_realize(ui.mainwin);
 469
 470         oswald_set_time(mtime.tm_hour, mtime.tm_min, mtime.tm_sec, TRUE);
 471         oswald_set_date(mtime.tm_mday, (mtime.tm_mon + 1), (mtime.tm_year + 1900), TRUE);
 472         oswald_init();
 473
 474         g_timeout_add_seconds(1, one_second_tmo_handler, &ui);
 475         // g_idle_add(app_idle_handler, &ui);
 476
 477         gtk_main ();
 478         return 0;
 479 }
 480