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 const char *hal_get_version_string(void)
  98 {
  99         return "GTK v0.3";
 100 }
 101
 102 const char *hal_get_buildno_string(void)
 103 {
 104         return BUILDNO;
 105 }
 106
 107 const char *hal_get_radio_version_string(void)
 108 {
 109         return "BlueZ";
 110 }
 111
 112 void hal_accelerometer_enable(void)
 113 {
 114         g_printerr("accel enable\n");
 115         gtk_widget_set_sensitive(ui_g->x_sc, TRUE);
 116         gtk_widget_set_sensitive(ui_g->y_sc, TRUE);
 117         gtk_widget_set_sensitive(ui_g->z_sc, TRUE);
 118 }
 119
 120 void hal_accelerometer_disable(void)
 121 {
 122         g_printerr("accel enable\n");
 123         gtk_widget_set_sensitive(ui_g->x_sc, FALSE);
 124         gtk_widget_set_sensitive(ui_g->y_sc, FALSE);
 125         gtk_widget_set_sensitive(ui_g->z_sc, FALSE);
 126 }
 127
 128
 129 static gint
 130 configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
 131 {
 132         oswald_ui *ui = (oswald_ui *)user_data;
 133
 134         if (ui->pixmap)
 135                 gdk_pixmap_unref(ui->pixmap);
 136
 137         ui->pixmap = gdk_pixmap_new(widget->window,
 138                 widget->allocation.width,
 139                 widget->allocation.height,
 140                 -1);
 141         gdk_draw_rectangle (ui->pixmap,
 142                 widget->style->white_gc,
 143                 TRUE,
 144                 0, 0,
 145                 widget->allocation.width,
 146                 widget->allocation.height);
 147
 148         return TRUE;
 149 }
 150
 151 static gint
 152 expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
 153 {
 154         oswald_ui *ui = (oswald_ui *)user_data;
 155
 156         gdk_draw_pixmap(widget->window,
 157                 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 158                 ui->pixmap,
 159                 event->area.x, event->area.y,
 160                 event->area.x, event->area.y,
 161                 event->area.width, event->area.height);
 162
 163         return FALSE;
 164 }
 165
 166 void button_A_clicked (GtkButton *button, gpointer user_data)
 167 {
 168         oswald_ui *ui = (oswald_ui *)user_data;
 169
 170         // g_print("Button-A clicked\n");
 171         oswald_handle_button_press(BUTTON_A);
 172 }
 173
 174 void button_B_clicked (GtkButton *button, gpointer user_data)
 175 {
 176         oswald_ui *ui = (oswald_ui *)user_data;
 177
 178         // g_print("Button-B clicked\n");
 179         oswald_handle_button_press(BUTTON_B);
 180 }
 181
 182 void button_C_clicked (GtkButton *button, gpointer user_data)
 183 {
 184         oswald_ui *ui = (oswald_ui *)user_data;
 185
 186         // g_print("Button-C clicked\n");
 187         oswald_handle_button_press(BUTTON_C);
 188 }
 189
 190 void button_D_clicked (GtkButton *button, gpointer user_data)
 191 {
 192         oswald_ui *ui = (oswald_ui *)user_data;
 193
 194         // g_print("Button-D clicked\n");
 195         oswald_handle_button_press(BUTTON_D);
 196 }
 197
 198 void button_E_clicked (GtkButton *button, gpointer user_data)
 199 {
 200         oswald_ui *ui = (oswald_ui *)user_data;
 201
 202         // g_print("Button-E clicked\n");
 203         oswald_handle_button_press(BUTTON_E);
 204 }
 205
 206 void button_F_clicked (GtkButton *button, gpointer user_data)
 207 {
 208         oswald_ui *ui = (oswald_ui *)user_data;
 209
 210         // g_print("Button-F clicked\n");
 211         oswald_handle_button_press(BUTTON_F);
 212 }
 213
 214 gboolean button_F_pr (GtkWidget *widget, GdkEvent *event, gpointer user_data)
 215 {
 216         oswald_ui *ui = (oswald_ui *)user_data;
 217         static gint32 press_time;
 218
 219         GdkEventButton *bev = (GdkEventButton *)event;
 220         if (bev->type == GDK_BUTTON_PRESS) {
 221                 press_time = bev->time;
 222                 return FALSE;
 223         };
 224         if (bev->type == GDK_BUTTON_RELEASE) {
 225                 if (bev->time > (press_time+1000)) {
 226                         g_print("Button-F long press\n");
 227                         return TRUE;
 228                 };
 229         };
 230
 231         return FALSE;
 232 }
 233
 234 void ambientlight_value_changed (GtkRange *range, gpointer  user_data)
 235 {
 236         oswald_ui *ui = (oswald_ui *)user_data;
 237         double val;
 238
 239         val = gtk_range_get_value(range);
 240         oswald_handle_ambientlight_event((uint8_t) val);
 241 }
 242
 243 void accelX_value_changed (GtkRange *range, gpointer  user_data)
 244 {
 245         oswald_ui *ui = (oswald_ui *)user_data;
 246         double val;
 247
 248         val = gtk_range_get_value(range);
 249         ui->accel_x = (uint8_t)val;
 250         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 251 }
 252
 253 void accelY_value_changed (GtkRange *range, gpointer  user_data)
 254 {
 255         oswald_ui *ui = (oswald_ui *)user_data;
 256         double val;
 257
 258         val = gtk_range_get_value(range);
 259         ui->accel_y = (uint8_t)val;
 260         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 261 }
 262
 263 void accelZ_value_changed (GtkRange *range, gpointer  user_data)
 264 {
 265         oswald_ui *ui = (oswald_ui *)user_data;
 266         double val;
 267
 268         val = gtk_range_get_value(range);
 269         ui->accel_z = (uint8_t)val;
 270         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 271 }
 272
 273 static void create_mainwin(oswald_ui *ui)
 274 {
 275         GtkWidget *mvb, *hb, *vb, *btn, *sc, *l;
 276
 277         ui->pixmap = NULL;
 278
 279         ui->mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 280         // gtk_window_set_default_size (GTK_WINDOW (ui->mainwin), 440, 240);
 281         g_signal_connect(G_OBJECT(ui->mainwin), "destroy", gtk_main_quit, NULL);
 282
 283         mvb = gtk_vbox_new(FALSE, 5);
 284         gtk_container_add(GTK_CONTAINER(ui->mainwin), mvb);
 285
 286         hb = gtk_hbox_new(FALSE, 5);
 287         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 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(" F ");
 293         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 294         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_F_clicked), ui);
 295         g_signal_connect(G_OBJECT(btn), "button-press-event", G_CALLBACK(button_F_pr), ui);
 296         g_signal_connect(G_OBJECT(btn), "button-release-event", G_CALLBACK(button_F_pr), ui);
 297
 298         btn = gtk_button_new_with_label(" E ");
 299         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 300         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_E_clicked), ui);
 301
 302         btn = gtk_button_new_with_label(" D ");
 303         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 304         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_D_clicked), ui);
 305
 306         ui->darea = gtk_drawing_area_new ();
 307         gtk_box_pack_start (GTK_BOX(hb), GTK_WIDGET(ui->darea), FALSE, FALSE, 5);
 308         gtk_drawing_area_size (GTK_DRAWING_AREA(ui->darea), BITMAP_WIDTH, BITMAP_HEIGHT);
 309
 310         gtk_signal_connect (GTK_OBJECT (ui->darea), "expose_event", (GtkSignalFunc) expose_event, ui);
 311         gtk_signal_connect (GTK_OBJECT (ui->darea), "configure_event", (GtkSignalFunc) configure_event, ui);
 312         // gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event", (GtkSignalFunc) motion_notify_event, ui);
 313         // gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event", (GtkSignalFunc) button_press_event, ui);
 314
 315         gtk_widget_set_events (GTK_WIDGET(ui->darea), GDK_EXPOSURE_MASK
 316                 | GDK_LEAVE_NOTIFY_MASK
 317                 | GDK_BUTTON_PRESS_MASK
 318                 | GDK_POINTER_MOTION_MASK
 319                 | GDK_POINTER_MOTION_HINT_MASK);
 320
 321         vb = gtk_vbox_new(FALSE, 5);
 322         gtk_box_pack_start (GTK_BOX(hb), vb, FALSE, FALSE, 5);
 323
 324         btn = gtk_button_new_with_label(" A ");
 325         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 326         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_A_clicked), ui);
 327
 328         btn = gtk_button_new_with_label(" B ");
 329         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 330         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_B_clicked), ui);
 331
 332         btn = gtk_button_new_with_label(" C ");
 333         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 334         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_C_clicked), ui);
 335
 336         // ambient light sensor
 337         sc = gtk_vscale_new_with_range (0, 255, 1);
 338         gtk_box_pack_start (GTK_BOX(hb), sc, FALSE, FALSE, 5);
 339         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(ambientlight_value_changed), ui);
 340
 341         hb = gtk_hbox_new(FALSE, 0);
 342         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 343
 344         l = gtk_label_new("X:");
 345         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 346         sc = gtk_hscale_new_with_range (-128, 127, 1);
 347         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 348         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelX_value_changed), ui);
 349         ui->x_sc = sc;
 350         gtk_widget_set_sensitive(ui->x_sc, FALSE);
 351
 352         l = gtk_label_new("Y:");
 353         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 354         sc = gtk_hscale_new_with_range (-128, 127, 1);
 355         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 356         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelY_value_changed), ui);
 357         ui->y_sc = sc;
 358         gtk_widget_set_sensitive(ui->y_sc, FALSE);
 359
 360         l = gtk_label_new("Z:");
 361         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 362         sc = gtk_hscale_new_with_range (-128, 127, 1);
 363         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 364         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelZ_value_changed), ui);
 365         ui->z_sc = sc;
 366         gtk_widget_set_sensitive(ui->z_sc, FALSE);
 367
 368         gtk_widget_show_all(ui->mainwin);
 369 }
 370
 371 static gboolean one_second_tmo_handler (gpointer userdata)
 372 {
 373         oswald_ui *ui = (oswald_ui *)userdata;
 374
 375         oswald_one_second_tick();
 376
 377         return TRUE;
 378 }
 379
 380 static gboolean app_idle_handler (gpointer user_data)
 381 {
 382         g_print("i");
 383         if (OswaldState.pending_idle) {
 384                 // call Oswald's idle function
 385                 return TRUE;
 386         };
 387         return FALSE;
 388 }
 389
 390 static gboolean centisecond_tmo_handler (gpointer userdata)
 391 {
 392         oswald_ui *ui = (oswald_ui *)userdata;
 393
 394         if (ui->centisecond_active)
 395                 oswald_centisecond_tick();
 396         else
 397                 return FALSE;
 398
 399         return TRUE;
 400 }
 401
 402 void hal_enable_centisecond_timer(void)
 403 {
 404         ui_g->centisecond_active = TRUE;
 405         g_timeout_add(10, centisecond_tmo_handler, ui_g);
 406 }
 407
 408 void hal_disable_centisecond_timer(void)
 409 {
 410         ui_g->centisecond_active = FALSE;
 411 }
 412
 413 static gboolean halfsecond_tmo_handler (gpointer userdata)
 414 {
 415         oswald_ui *ui = (oswald_ui *)userdata;
 416
 417         if (ui->halfsecond_active)
 418                 oswald_halfsecond_tick();
 419         else
 420                 return FALSE;
 421
 422         return TRUE;
 423 }
 424
 425 void hal_enable_halfsecond_timer(void)
 426 {
 427         ui_g->halfsecond_active = TRUE;
 428         g_timeout_add(500, halfsecond_tmo_handler, ui_g);
 429 }
 430
 431 void hal_disable_halfsecond_timer(void)
 432 {
 433         ui_g->halfsecond_active = FALSE;
 434 }
 435
 436 void hal_get_rtc(clock_state *rtc)
 437 {
 438         time_t mt;
 439         struct tm mtime;
 440
 441         mt = time(NULL);
 442         localtime_r(&mt, &mtime);
 443
 444         rtc->hour = mtime.tm_hour;
 445         rtc->minute = mtime.tm_min;
 446         rtc->second = mtime.tm_sec;
 447         rtc->day = mtime.tm_mday;
 448         rtc->month = (mtime.tm_mon + 1);
 449         rtc->year = (mtime.tm_year + 1900);
 450 }
 451
 452 void hal_set_rtc(const clock_state *rtc, boolean set_set)
 453 {
 454 }
 455
 456 void hal_get_power_state(power_state *pwr)
 457 {
 458 }
 459
 460 static boolean BacklightState = FALSE;
 461
 462 /* sets the backlight on/off, on=TRUE, off=FALSE */
 463 void hal_lcd_set_backlight(boolean state)
 464 {
 465         g_print("turn LCD backlight %s\n", state ? "on" : "off");
 466         BacklightState = state;
 467 }
 468
 469 boolean hal_lcd_get_backlight(void)
 470 {
 471         return BacklightState;
 472 }
 473
 474
 475 /* sets the vibration motor on/off, on=TRUE, off=FALSE */
 476 void hal_vibration_set_state(boolean state)
 477 {
 478 }
 479
 480 boolean hal_vibration_get_state(void)
 481 {
 482         return FALSE;
 483 }
 484
 485
 486 int main(int argc , char ** argv)
 487 {
 488         oswald_ui ui;
 489         time_t mt;
 490         struct tm mtime;
 491
 492         ui_g = &ui;
 493
 494         ui.accel_x = 0;
 495         ui.accel_y = 0;
 496         ui.accel_z = 0;
 497         ui.halfsecond_active = FALSE;
 498         ui.centisecond_active = FALSE;
 499
 500         mt = time(NULL);
 501         localtime_r(&mt, &mtime);
 502
 503         gtk_init (&argc, &argv);
 504
 505         create_mainwin(&ui);
 506         gtk_widget_realize(ui.mainwin);
 507
 508         oswald_set_time(mtime.tm_hour, mtime.tm_min, mtime.tm_sec, TRUE);
 509         oswald_set_date(mtime.tm_mday, (mtime.tm_mon + 1), (mtime.tm_year + 1900), TRUE);
 510         oswald_init();
 511
 512         g_timeout_add_seconds(1, one_second_tmo_handler, &ui);
 513         // g_idle_add(app_idle_handler, &ui);
 514
 515         gtk_main ();
 516         return 0;
 517 }
 518