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