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 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         gtk_widget_queue_draw(ui_g->darea);
  39 }
  40
  41 void lcd_clear_display(void)
  42 {
  43         gdk_draw_rectangle (ui_g->pixmap,
  44                 ui_g->darea->style->white_gc,
  45                 TRUE,
  46                 0, 0,
  47                 ui_g->darea->allocation.width,
  48                 ui_g->darea->allocation.height);
  49
  50         gtk_widget_queue_draw(ui_g->darea);
  51 }
  52
  53 static gint
  54 configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
  55 {
  56         oswald_ui *ui = (oswald_ui *)user_data;
  57
  58         if (ui->pixmap)
  59                 gdk_pixmap_unref(ui->pixmap);
  60
  61         ui->pixmap = gdk_pixmap_new(widget->window,
  62                 widget->allocation.width,
  63                 widget->allocation.height,
  64                 -1);
  65         gdk_draw_rectangle (ui->pixmap,
  66                 widget->style->white_gc,
  67                 TRUE,
  68                 0, 0,
  69                 widget->allocation.width,
  70                 widget->allocation.height);
  71
  72         return TRUE;
  73 }
  74
  75 static gint
  76 expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
  77 {
  78         oswald_ui *ui = (oswald_ui *)user_data;
  79
  80         gdk_draw_pixmap(widget->window,
  81                 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
  82                 ui->pixmap,
  83                 event->area.x, event->area.y,
  84                 event->area.x, event->area.y,
  85                 event->area.width, event->area.height);
  86
  87         return FALSE;
  88 }
  89
  90 void button_A_clicked (GtkButton *button, gpointer user_data)
  91 {
  92         oswald_ui *ui = (oswald_ui *)user_data;
  93
  94         // g_print("Button-A clicked\n");
  95         oswald_handle_button_press(BUTTON_A);
  96 }
  97
  98 void button_B_clicked (GtkButton *button, gpointer user_data)
  99 {
 100         oswald_ui *ui = (oswald_ui *)user_data;
 101
 102         // g_print("Button-B clicked\n");
 103         oswald_handle_button_press(BUTTON_B);
 104 }
 105
 106 void button_C_clicked (GtkButton *button, gpointer user_data)
 107 {
 108         oswald_ui *ui = (oswald_ui *)user_data;
 109
 110         // g_print("Button-C clicked\n");
 111         oswald_handle_button_press(BUTTON_C);
 112 }
 113
 114 void button_D_clicked (GtkButton *button, gpointer user_data)
 115 {
 116         oswald_ui *ui = (oswald_ui *)user_data;
 117
 118         // g_print("Button-D clicked\n");
 119         oswald_handle_button_press(BUTTON_D);
 120 }
 121
 122 void button_E_clicked (GtkButton *button, gpointer user_data)
 123 {
 124         oswald_ui *ui = (oswald_ui *)user_data;
 125
 126         // g_print("Button-E clicked\n");
 127         oswald_handle_button_press(BUTTON_E);
 128 }
 129
 130 void button_F_clicked (GtkButton *button, gpointer user_data)
 131 {
 132         oswald_ui *ui = (oswald_ui *)user_data;
 133
 134         // g_print("Button-F clicked\n");
 135         oswald_handle_button_press(BUTTON_F);
 136 }
 137
 138 gboolean button_F_pr (GtkWidget *widget, GdkEvent *event, gpointer user_data)
 139 {
 140         oswald_ui *ui = (oswald_ui *)user_data;
 141         static gint32 press_time;
 142
 143         GdkEventButton *bev = (GdkEventButton *)event;
 144         if (bev->type == GDK_BUTTON_PRESS) {
 145                 press_time = bev->time;
 146                 return FALSE;
 147         };
 148         if (bev->type == GDK_BUTTON_RELEASE) {
 149                 if (bev->time > (press_time+1000)) {
 150                         g_print("Button-F long press\n");
 151                         return TRUE;
 152                 };
 153         };
 154
 155         return FALSE;
 156 }
 157
 158 void ambientlight_value_changed (GtkRange *range, gpointer  user_data)
 159 {
 160         oswald_ui *ui = (oswald_ui *)user_data;
 161         double val;
 162
 163         val = gtk_range_get_value(range);
 164         oswald_handle_ambientlight_event((u8t) val);
 165 }
 166
 167 void accelX_value_changed (GtkRange *range, gpointer  user_data)
 168 {
 169         oswald_ui *ui = (oswald_ui *)user_data;
 170         double val;
 171
 172         val = gtk_range_get_value(range);
 173         ui->accel_x = (u8t)val;
 174         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 175 }
 176
 177 void accelY_value_changed (GtkRange *range, gpointer  user_data)
 178 {
 179         oswald_ui *ui = (oswald_ui *)user_data;
 180         double val;
 181
 182         val = gtk_range_get_value(range);
 183         ui->accel_y = (u8t)val;
 184         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 185 }
 186
 187 void accelZ_value_changed (GtkRange *range, gpointer  user_data)
 188 {
 189         oswald_ui *ui = (oswald_ui *)user_data;
 190         double val;
 191
 192         val = gtk_range_get_value(range);
 193         ui->accel_z = (u8t)val;
 194         oswald_handle_accel_event(ui->accel_x, ui->accel_y, ui->accel_z);
 195 }
 196
 197 static void create_mainwin(oswald_ui *ui)
 198 {
 199         GtkWidget *mvb, *hb, *vb, *btn, *sc, *l;
 200
 201         ui->pixmap = NULL;
 202
 203         ui->mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 204         // gtk_window_set_default_size (GTK_WINDOW (ui->mainwin), 440, 240);
 205         g_signal_connect(G_OBJECT(ui->mainwin), "destroy", gtk_main_quit, NULL);
 206
 207         mvb = gtk_vbox_new(FALSE, 5);
 208         gtk_container_add(GTK_CONTAINER(ui->mainwin), mvb);
 209
 210         hb = gtk_hbox_new(FALSE, 5);
 211         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 212
 213         vb = gtk_vbox_new(FALSE, 5);
 214         gtk_box_pack_start (GTK_BOX(hb), vb, FALSE, FALSE, 5);
 215
 216         btn = gtk_button_new_with_label(" D ");
 217         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 218         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_D_clicked), ui);
 219
 220         btn = gtk_button_new_with_label(" E ");
 221         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 222         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_E_clicked), ui);
 223
 224         btn = gtk_button_new_with_label(" F ");
 225         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 226         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_F_clicked), ui);
 227         g_signal_connect(G_OBJECT(btn), "button-press-event", G_CALLBACK(button_F_pr), ui);
 228         g_signal_connect(G_OBJECT(btn), "button-release-event", G_CALLBACK(button_F_pr), ui);
 229
 230         ui->darea = gtk_drawing_area_new ();
 231         gtk_box_pack_start (GTK_BOX(hb), GTK_WIDGET(ui->darea), FALSE, FALSE, 5);
 232         gtk_drawing_area_size (GTK_DRAWING_AREA(ui->darea), BITMAP_WIDTH, BITMAP_HEIGHT);
 233
 234         gtk_signal_connect (GTK_OBJECT (ui->darea), "expose_event", (GtkSignalFunc) expose_event, ui);
 235         gtk_signal_connect (GTK_OBJECT (ui->darea), "configure_event", (GtkSignalFunc) configure_event, ui);
 236         // gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event", (GtkSignalFunc) motion_notify_event, ui);
 237         // gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event", (GtkSignalFunc) button_press_event, ui);
 238
 239         gtk_widget_set_events (GTK_WIDGET(ui->darea), GDK_EXPOSURE_MASK
 240                 | GDK_LEAVE_NOTIFY_MASK
 241                 | GDK_BUTTON_PRESS_MASK
 242                 | GDK_POINTER_MOTION_MASK
 243                 | GDK_POINTER_MOTION_HINT_MASK);
 244
 245         vb = gtk_vbox_new(FALSE, 5);
 246         gtk_box_pack_start (GTK_BOX(hb), vb, FALSE, FALSE, 5);
 247
 248         btn = gtk_button_new_with_label(" A ");
 249         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 250         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_A_clicked), ui);
 251
 252         btn = gtk_button_new_with_label(" B ");
 253         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 254         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_B_clicked), ui);
 255
 256         btn = gtk_button_new_with_label(" C ");
 257         gtk_box_pack_start (GTK_BOX(vb), btn, FALSE, FALSE, 10);
 258         g_signal_connect(G_OBJECT(btn), "clicked", G_CALLBACK(button_C_clicked), ui);
 259
 260         // ambient light sensor
 261         sc = gtk_vscale_new_with_range (0, 255, 1);
 262         gtk_box_pack_start (GTK_BOX(hb), sc, FALSE, FALSE, 5);
 263         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(ambientlight_value_changed), ui);
 264
 265         hb = gtk_hbox_new(FALSE, 0);
 266         gtk_box_pack_start (GTK_BOX(mvb), hb, FALSE, FALSE, 5);
 267
 268         l = gtk_label_new("X:");
 269         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 270         sc = gtk_hscale_new_with_range (0, 255, 1);
 271         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 272         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelX_value_changed), ui);
 273
 274         l = gtk_label_new("Y:");
 275         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 276         sc = gtk_hscale_new_with_range (0, 255, 1);
 277         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 278         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelY_value_changed), ui);
 279
 280         l = gtk_label_new("Z:");
 281         gtk_box_pack_start (GTK_BOX(hb), l, FALSE, FALSE, 5);
 282         sc = gtk_hscale_new_with_range (0, 255, 1);
 283         gtk_box_pack_start (GTK_BOX(hb), sc, TRUE, TRUE, 5);
 284         g_signal_connect(G_OBJECT(sc), "value-changed", G_CALLBACK(accelZ_value_changed), ui);
 285
 286         gtk_widget_show_all(ui->mainwin);
 287 }
 288
 289 static gboolean one_second_tmo_handler (gpointer userdata)
 290 {
 291         oswald_ui *ui = (oswald_ui *)userdata;
 292
 293         oswald_one_second_tick();
 294
 295         return TRUE;
 296 }
 297
 298 static gboolean app_idle_handler (gpointer user_data)
 299 {
 300         g_print("i");
 301         if (OswaldState.pending_idle) {
 302                 // call Oswald's idle function
 303                 return TRUE;
 304         };
 305         return FALSE;
 306 }
 307
 308 static gboolean centisecond_tmo_handler (gpointer userdata)
 309 {
 310         oswald_ui *ui = (oswald_ui *)userdata;
 311
 312         if (ui->centisecond_active)
 313                 oswald_centisecond_tick();
 314         else
 315                 return FALSE;
 316
 317         return TRUE;
 318 }
 319
 320 void enable_centisecond_timer(void)
 321 {
 322         ui_g->centisecond_active = TRUE;
 323         g_timeout_add(10, centisecond_tmo_handler, ui_g);
 324 }
 325
 326 void disable_centisecond_timer(void)
 327 {
 328         ui_g->centisecond_active = FALSE;
 329 }
 330
 331 static gboolean halfsecond_tmo_handler (gpointer userdata)
 332 {
 333         oswald_ui *ui = (oswald_ui *)userdata;
 334
 335         if (ui->halfsecond_active)
 336                 oswald_halfsecond_tick();
 337         else
 338                 return FALSE;
 339
 340         return TRUE;
 341 }
 342
 343 void enable_halfsecond_timer(void)
 344 {
 345         ui_g->halfsecond_active = TRUE;
 346         g_timeout_add(500, halfsecond_tmo_handler, ui_g);
 347 }
 348
 349 void disable_halfsecond_timer(void)
 350 {
 351         ui_g->halfsecond_active = FALSE;
 352 }
 353
 354 int main(int argc , char ** argv)
 355 {
 356         oswald_ui ui;
 357         time_t mt;
 358         struct tm mtime;
 359
 360         ui_g = &ui;
 361
 362         ui.accel_x = 0;
 363         ui.accel_y = 0;
 364         ui.accel_z = 0;
 365         ui.halfsecond_active = FALSE;
 366         ui.centisecond_active = FALSE;
 367
 368         mt = time(NULL);
 369         localtime_r(&mt, &mtime);
 370
 371         gtk_init (&argc, &argv);
 372
 373         create_mainwin(&ui);
 374         gtk_widget_realize(ui.mainwin);
 375
 376         oswald_set_time(mtime.tm_hour, mtime.tm_min, mtime.tm_sec, TRUE);
 377         oswald_set_date(mtime.tm_mday, (mtime.tm_mon + 1), (mtime.tm_year + 1900), TRUE);
 378         oswald_init();
 379
 380         g_timeout_add_seconds(1, one_second_tmo_handler, &ui);
 381         // g_idle_add(app_idle_handler, &ui);
 382
 383         gtk_main ();
 384         return 0;
 385 }
 386