err.no Git - mapper/blob - src/gtkgps.c

   1 /*
   2  *
   3  * GtkGps: Display GPS information
   4  * Copyright (C) 2007 Kaj-Michael Lang
   5  * Originanl non-widget version Copyright Cezary Jackiewicz
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the Free
  19  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <math.h>
  23
  24 #include <glib/gstdio.h>
  25 #include <glib-object.h>
  26 #include "gtkgps.h"
  27
  28 static void gtk_gps_finalize (GObject *object);
  29 static void gtk_gps_size_request (GtkWidget *widget, GtkRequisition *requisition);
  30 static void gtk_gps_size_allocate (GtkWidget *widget, GtkAllocation *allocate);
  31 static gboolean gtk_gps_expose (GtkWidget *widget, GdkEventExpose *event);
  32 static void gtk_gps_realize (GtkWidget *widget);
  33 static void gtk_gps_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  34 static void gtk_gps_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  35 static void gtk_gps_paint_by_mode(GtkGps *gps);
  36 static gboolean gtk_gps_refresh_cb(GtkWidget *widget);
  37
  38 G_DEFINE_TYPE(GtkGps, gtk_gps, GTK_TYPE_WIDGET);
  39
  40 #define PADDING (15)
  41
  42 #define BOUND(x, a, b) { \
  43     if((x) < (a)) \
  44         (x) = (a); \
  45     else if((x) > (b)) \
  46         (x) = (b); \
  47 }
  48
  49 static void
  50 gtk_gps_class_init(GtkGpsClass *class)
  51 {
  52 GObjectClass *object_class;
  53 GtkWidgetClass *widget_class;
  54
  55 object_class = (GObjectClass*) class;
  56 widget_class = (GtkWidgetClass*) class;
  57
  58 object_class->finalize = gtk_gps_finalize;
  59 object_class->set_property = gtk_gps_set_property;
  60 object_class->get_property = gtk_gps_get_property;
  61
  62 widget_class->size_request = gtk_gps_size_request;
  63 widget_class->expose_event = gtk_gps_expose;
  64 widget_class->realize = gtk_gps_realize;
  65 widget_class->size_allocate = gtk_gps_size_allocate;
  66 }
  67
  68 static void
  69 gtk_gps_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
  70 {
  71 GtkGps *gps;
  72
  73 g_return_if_fail(GTK_IS_GPS(object));
  74
  75 gps=GTK_GPS(object);
  76 switch (prop_id) {
  77         default:
  78                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  79         break;
  80 }
  81 }
  82
  83 static void
  84 gtk_gps_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec   *pspec)
  85 {
  86 GtkGps *gps;
  87
  88 g_return_if_fail(GTK_IS_GPS(object));
  89
  90 gps=GTK_GPS(object);
  91 switch (prop_id) {
  92         default:
  93                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  94         break;
  95 }
  96 }
  97
  98 static void
  99 gtk_gps_init(GtkGps *gps)
 100 {
 101 gps->gc_w=NULL;
 102 gps->gc_s=NULL;
 103 gps->gc_sf=NULL;
 104 gps->width=300;
 105 gps->height=300;
 106 gps->size=300;
 107 gps->esid=0;
 108 }
 109
 110 static gboolean
 111 gtk_gps_cb_button_press(GtkWidget * widget, GdkEventButton * event)
 112 {
 113 GtkGps *gps;
 114
 115 gps=GTK_GPS(widget);
 116
 117 if (event->button==1) {
 118         switch (gps->display_mode) {
 119         case GTK_GPS_MODE_SKY:
 120                 gps->display_mode=GTK_GPS_MODE_SIGNAL;
 121         break;
 122         case GTK_GPS_MODE_SIGNAL:
 123         default:
 124                 gps->display_mode=GTK_GPS_MODE_SKY;
 125         break;
 126         }
 127 }
 128 gtk_widget_queue_draw_area(widget, 0, 0, gps->width, gps->height);
 129 return FALSE;
 130 }
 131
 132 GtkWidget*
 133 gtk_gps_new(GtkGpsMode display_mode, GpsData *data)
 134 {
 135 GtkGps *gps;
 136 GtkWidget *widget;
 137
 138 gps=gtk_type_new(gtk_gps_get_type ());
 139 gps->display_mode=display_mode;
 140 gps->data=data;
 141 widget=GTK_WIDGET(gps);
 142
 143 /* Allow switching if mode is combined */
 144 if (display_mode==GTK_GPS_MODE_COMBINED) {
 145         g_signal_connect(G_OBJECT(widget), "button_press_event", G_CALLBACK(gtk_gps_cb_button_press), NULL);
 146         display_mode=GTK_GPS_MODE_SKY;
 147 }
 148
 149 gps->context=gtk_widget_get_pango_context(widget);
 150 gps->layout=pango_layout_new(gps->context);
 151 gps->fontdesc=pango_font_description_new();
 152 pango_font_description_set_family(gps->fontdesc, "Sans Serif");
 153 pango_font_description_set_size(gps->fontdesc, 10*PANGO_SCALE);
 154 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 155 pango_layout_set_alignment(gps->layout, PANGO_ALIGN_CENTER);
 156
 157 gps->esid=g_timeout_add(1000,(GSourceFunc)gtk_gps_refresh_cb, gps);
 158
 159 return GTK_WIDGET(gps);
 160 }
 161
 162 static void
 163 gtk_gps_finalize(GObject *object)
 164 {
 165 GtkGps *gps;
 166
 167 g_return_if_fail(GTK_IS_GPS(object));
 168 gps=GTK_GPS(object);
 169
 170 g_source_remove(gps->esid);
 171 if (GTK_WIDGET(object)->parent && GTK_WIDGET_MAPPED(object)) {
 172         gtk_widget_unmap(GTK_WIDGET(object));
 173 }
 174
 175 G_OBJECT_CLASS(gtk_gps_parent_class)->finalize(object);
 176 }
 177
 178 static void
 179 gtk_gps_size_request(GtkWidget  *widget, GtkRequisition *requisition)
 180 {
 181 GtkGps *gps;
 182
 183 g_return_if_fail(GTK_IS_GPS(widget));
 184 g_return_if_fail(requisition!=NULL);
 185
 186 gps = GTK_GPS (widget);
 187
 188 requisition->width=300;
 189 gps->width=300;
 190
 191 if (gps->display_mode==GTK_GPS_MODE_SKY) {
 192         requisition->height=400;
 193         gps->height=400;
 194 } else {
 195         requisition->height=200;
 196         gps->height=200;
 197 }
 198 gps->size=300;
 199 }
 200
 201 static void
 202 gtk_gps_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 203 {
 204 GtkGps *gps;
 205
 206 g_return_if_fail(GTK_IS_GPS(widget));
 207 g_return_if_fail(allocation!=NULL);
 208
 209 gps=GTK_GPS (widget);
 210
 211 widget->allocation = *allocation;
 212
 213 if (GTK_WIDGET_REALIZED (widget)) {
 214         gdk_window_move_resize (widget->window,
 215                 allocation->x, allocation->y,
 216                 allocation->width, allocation->height);
 217 }
 218
 219 gps->width=allocation->width;
 220 gps->height=allocation->height;
 221 gps->size=MIN(gps->width, gps->height);
 222
 223 gps->fs=gps->size/22;
 224 BOUND(gps->fs, 10, 24);
 225
 226 pango_font_description_set_size(gps->fontdesc, (gps->fs-3)*PANGO_SCALE);
 227 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 228 }
 229
 230 static void
 231 gtk_gps_realize (GtkWidget *widget)
 232 {
 233 GtkGps *gps;
 234 GdkColor color;
 235 GdkWindowAttr attributes;
 236 gint attributes_mask;
 237
 238 g_return_if_fail (GTK_IS_GPS(widget));
 239 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 240 gps=GTK_GPS(widget);
 241
 242 attributes.x=widget->allocation.x;
 243 attributes.y=widget->allocation.y;
 244 attributes.width=widget->allocation.width;
 245 attributes.height=widget->allocation.height;
 246 attributes.wclass=GDK_INPUT_OUTPUT;
 247 attributes.window_type=GDK_WINDOW_CHILD;
 248 attributes.event_mask=gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
 249 attributes.visual=gtk_widget_get_visual(widget);
 250 attributes.colormap=gtk_widget_get_colormap(widget);
 251
 252 attributes_mask=GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 253
 254 widget->window=gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
 255 widget->style=gtk_style_attach(widget->style, widget->window);
 256
 257 gdk_window_set_user_data(widget->window, widget);
 258 gtk_style_set_background(widget->style, widget->window, GTK_STATE_ACTIVE);
 259
 260 /* No fix */
 261 if (!gps->gc_s) {
 262         color.red=0;
 263         color.green=0;
 264         color.blue=0x1000;
 265         gps->gc_s=gdk_gc_new(widget->window);
 266         gdk_gc_set_rgb_fg_color(gps->gc_s, &color);
 267 }
 268
 269 /* Fix color */
 270 if (!gps->gc_sf) {
 271         color.red=0;
 272         color.green=0xdfff;
 273         color.blue=0;
 274         gps->gc_sf=gdk_gc_new(widget->window);
 275         gdk_gc_set_rgb_fg_color(gps->gc_sf, &color);
 276 }
 277
 278 if (!gps->gc_w) {
 279         color.red=0xffff;
 280         color.green=0xffff;
 281         color.blue=0xffff;
 282         gps->gc_w=gdk_gc_new(widget->window);
 283         gdk_gc_set_rgb_fg_color(gps->gc_w, &color);
 284 }
 285 }
 286
 287 static void
 288 gtk_gps_paint_sky(GtkGps *gps)
 289 {
 290 GdkGC *gc;
 291 GtkWidget *widget;
 292 guint i, x, y, size, halfsize, xoffset, yoffset;
 293 guint x1, y1, x0, y0;
 294 gfloat tmp;
 295 gchar buffer[16];
 296 guint line[12]={0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330};
 297
 298 widget=GTK_WIDGET(gps);
 299
 300 g_return_if_fail(gps->data);
 301
 302 if (!GTK_WIDGET_MAPPED(widget))
 303         return;
 304
 305 x0=0;
 306 y0=0;
 307
 308 size=gps->size-PADDING;
 309 halfsize=size/2;
 310 if (gps->width>gps->height) {
 311         xoffset=x0+(gps->width-gps->height)/2;
 312         yoffset=y0+5;
 313 } else {
 314         xoffset=x0+5;
 315         yoffset=y0+(gps->height-gps->width)/2;
 316 }
 317
 318 /* 90 */
 319 gdk_draw_arc(widget->window,
 320              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 321              FALSE,
 322              xoffset + 2, yoffset + 2, size - 4, size - 4, 0, 64 * 360);
 323
 324 /* 60 */
 325 gdk_draw_arc(widget->window,
 326              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 327              FALSE,
 328              xoffset + size / 6, yoffset + size / 6,
 329              size / 6 * 4, size / 6 * 4, 0, 64 * 360);
 330
 331 /* 30 */
 332 gdk_draw_arc(widget->window,
 333              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 334              FALSE,
 335              xoffset + size / 6 * 2, yoffset + size / 6 * 2,
 336              size / 6 * 2, size / 6 * 2, 0, 64 * 360);
 337
 338 for (i = 0; i < 12; i++) {
 339         gfloat sint, cost;
 340
 341         tmp = (line[i] * (1.f / 180.f)) * G_PI;
 342         sint=sinf(tmp);
 343         cost=cosf(tmp);
 344         /* line */
 345         gdk_draw_line(widget->window,
 346                       widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 347                       xoffset + halfsize + (halfsize - 2) * sint,
 348                       yoffset + halfsize - (halfsize - 2) * cost,
 349                       xoffset + halfsize - (halfsize - 2) * sint,
 350                       yoffset + halfsize + (halfsize - 2) * cost);
 351
 352         /* Skip angle text if there is no space */
 353         if (size<100)
 354                 continue;
 355
 356         if (line[i] == 0)
 357                 g_snprintf(buffer, 16, "N");
 358         else
 359                 g_snprintf(buffer, 16, "%d°", line[i]);
 360         pango_layout_set_text(gps->layout, buffer, -1);
 361         pango_layout_get_pixel_size(gps->layout, &x, &y);
 362         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 363                         (xoffset + halfsize + (halfsize - size / 12) * sint) - x / 2,
 364                         (yoffset + halfsize - (halfsize - size / 12) * cost) - y / 2,
 365                         gps->layout);
 366
 367 }
 368
 369 if (size>100) {
 370         tmp = (30 * (1.f / 180.f)) * G_PI;
 371         /* elevation 30 */
 372         g_snprintf(buffer, 16, "30°");
 373         pango_layout_set_text(gps->layout, buffer, -1);
 374         pango_layout_get_pixel_size(gps->layout, &x, &y);
 375         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 376                 (xoffset + halfsize + size / 6 * 2 * sinf(tmp)) - x / 2,
 377                 (yoffset + halfsize - size / 6 * 2 * cosf(tmp)) - y / 2,
 378                 gps->layout);
 379
 380         /* elevation 60 */
 381         g_snprintf(buffer, 16, "60°");
 382         pango_layout_set_text(gps->layout, buffer, -1);
 383         pango_layout_get_pixel_size(gps->layout, &x, &y);
 384         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 385                 (xoffset + halfsize + size / 6 * sinf(tmp)) - x / 2,
 386                 (yoffset + halfsize - size / 6 * cosf(tmp)) - y / 2,
 387                 gps->layout);
 388 }
 389
 390 for (i=0;i<gps->data->satinview;i++) {
 391         /* Sat used or not */
 392         gc=(gps->data->sat[i].fix==TRUE) ? gps->gc_sf : gps->gc_s;
 393
 394         tmp = (gps->data->sat[i].azimuth * (1.f / 180.f)) * G_PI;
 395         x = xoffset + halfsize + (90 - gps->data->sat[i].elevation) * halfsize / 90 * sinf(tmp);
 396         y = yoffset + halfsize - (90 - gps->data->sat[i].elevation) * halfsize / 90 * cosf(tmp);
 397
 398         gdk_draw_arc(widget->window, gc, TRUE, x-gps->fs, y-gps->fs, gps->fs+8, gps->fs+8, 0, 64 * 360);
 399
 400         g_snprintf(buffer, 6, "%02d", gps->data->sat[i].prn);
 401         pango_layout_set_text(gps->layout, buffer, -1);
 402         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 403         gdk_draw_layout(widget->window, gps->gc_w, x-gps->fs/2-x1/2+2, y-gps->fs/2-y1/2+2, gps->layout);
 404 }
 405
 406 return;
 407 }
 408
 409 static void
 410 gtk_gps_paint_signals(GtkGps *gps)
 411 {
 412 GdkGC *gc;
 413 GtkWidget *widget;
 414 guint step, i, snr_height, bymargin, xoffset, yoffset;
 415 guint x, y, x1, y1;
 416 gchar tmp[32];
 417
 418 widget=GTK_WIDGET(gps);
 419
 420 if (!GTK_WIDGET_MAPPED(widget))
 421         return;
 422
 423 xoffset=0;
 424 yoffset=0;
 425
 426 /* Bootom margin - 12% */
 427 bymargin = gps->height * 0.88f;
 428
 429 /* Bottom line */
 430 gdk_draw_line(widget->window,
 431               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 432               xoffset + 5, yoffset + bymargin,
 433               xoffset + gps->width - 10 - 2, yoffset + bymargin);
 434 gdk_draw_line(widget->window,
 435               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 436               xoffset + 5, yoffset + bymargin - 1,
 437               xoffset + gps->width - 10 - 2, yoffset + bymargin - 1);
 438
 439 if (gps->data->satinview==0)
 440         return;
 441
 442 /* Left margin - 5pix, Right margin - 5pix */
 443 step = (gps->width - 10) / gps->data->satinview;
 444
 445 for (i=0;i<gps->data->satinview;i++) {
 446         /* Sat used or not */
 447         gc=(gps->data->sat[i].fix) ? gps->gc_sf : gps->gc_s;
 448
 449         x = 5 + i * step;
 450         snr_height = gps->data->sat[i].snr * gps->height * 0.78f / 100;
 451         y = gps->height * 0.1f + (gps->height * 0.78f - snr_height);
 452
 453         /* draw sat rectangle... */
 454         gdk_draw_rectangle(widget->window,
 455                            gc, TRUE,
 456                            xoffset + x,
 457                            yoffset + y, step - 2, snr_height);
 458
 459         if (gps->data->sat[i].snr>0) {
 460                 /* ...snr.. */
 461                 g_snprintf(tmp, 32, "%02d", gps->data->sat[i].snr);
 462                 pango_layout_set_text(gps->layout, tmp, 2);
 463                 pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 464                 gdk_draw_layout(widget->window,
 465                                 widget->style->fg_gc[GTK_STATE_NORMAL],
 466                                 xoffset + x + ((step - 2) - x1) / 2,
 467                                 yoffset + y - 15,
 468                                 gps->layout);
 469         }
 470
 471         /* ...and sat number */
 472         g_snprintf(tmp, 32, "%02d", gps->data->sat[i].prn);
 473         pango_layout_set_text(gps->layout, tmp, 2);
 474         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 475         gdk_draw_layout(widget->window,
 476                         widget->style->fg_gc[GTK_STATE_NORMAL],
 477                         xoffset + x + ((step - 2) - x1) / 2,
 478                         yoffset + bymargin + 1,
 479                         gps->layout);
 480 }
 481
 482 }
 483
 484 static void
 485 gtk_gps_paint_by_mode(GtkGps *gps)
 486 {
 487 g_return_if_fail(GTK_IS_GPS(gps));
 488
 489 switch (gps->display_mode) {
 490         case GTK_GPS_MODE_SIGNAL:
 491                 gtk_gps_paint_signals(gps);
 492         break;
 493         case GTK_GPS_MODE_SKY:
 494         default:
 495                 gtk_gps_paint_sky(gps);
 496         break;
 497 }
 498 }
 499
 500 static gboolean
 501 gtk_gps_refresh_cb(GtkWidget *widget)
 502 {
 503 GtkGps *gps;
 504
 505 g_return_val_if_fail(GTK_IS_GPS(widget), FALSE);
 506
 507 if ((GTK_WIDGET_MAPPED(widget)==FALSE) || (GTK_WIDGET_VISIBLE(widget)==FALSE))
 508         return TRUE;
 509
 510 gps=GTK_GPS(widget);
 511 gtk_widget_queue_draw_area(widget, 0, 0, gps->width, gps->height);
 512 return TRUE;
 513 }
 514
 515 static gboolean
 516 gtk_gps_expose(GtkWidget *widget, GdkEventExpose *event)
 517 {
 518 GtkGps *gps;
 519
 520 g_return_val_if_fail(GTK_IS_GPS(widget), FALSE);
 521 g_return_val_if_fail(event != NULL, FALSE);
 522
 523 gps=GTK_GPS(widget);
 524 gtk_gps_paint_by_mode(gps);
 525 return TRUE;
 526 }
 527
 528 void
 529 gtk_gps_refresh(GtkWidget *widget)
 530 {
 531 GtkGps *gps;
 532
 533 g_return_if_fail(GTK_IS_GPS(widget));
 534
 535 gps=GTK_GPS(widget);
 536 gtk_widget_queue_draw_area(widget, 0, 0, gps->width, gps->height);
 537 }