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