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
  37 G_DEFINE_TYPE(GtkGps, gtk_gps, GTK_TYPE_WIDGET);
  38
  39 #define PADDING (15)
  40
  41 #define BOUND(x, a, b) { \
  42     if((x) < (a)) \
  43         (x) = (a); \
  44     else if((x) > (b)) \
  45         (x) = (b); \
  46 }
  47
  48 static void
  49 gtk_gps_class_init(GtkGpsClass *class)
  50 {
  51 GObjectClass *object_class;
  52 GtkWidgetClass *widget_class;
  53
  54 object_class = (GObjectClass*) class;
  55 widget_class = (GtkWidgetClass*) class;
  56
  57 object_class->finalize = gtk_gps_finalize;
  58 object_class->set_property = gtk_gps_set_property;
  59 object_class->get_property = gtk_gps_get_property;
  60
  61 widget_class->size_request = gtk_gps_size_request;
  62 widget_class->expose_event = gtk_gps_expose;
  63 widget_class->realize = gtk_gps_realize;
  64 widget_class->size_allocate = gtk_gps_size_allocate;
  65 }
  66
  67 static void
  68 gtk_gps_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
  69 {
  70 GtkGps *gps;
  71
  72 g_return_if_fail(GTK_IS_GPS(object));
  73
  74 gps=GTK_GPS(object);
  75 switch (prop_id) {
  76         default:
  77                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  78         break;
  79 }
  80 }
  81
  82 static void
  83 gtk_gps_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec   *pspec)
  84 {
  85 GtkGps *gps;
  86
  87 g_return_if_fail(GTK_IS_GPS(object));
  88
  89 gps=GTK_GPS(object);
  90 switch (prop_id) {
  91         default:
  92                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  93         break;
  94 }
  95 }
  96
  97 static void
  98 gtk_gps_init(GtkGps *gps)
  99 {
 100 g_printf("%s()\n", __PRETTY_FUNCTION__);
 101
 102 gps->gc_w=NULL;
 103 gps->gc_s=NULL;
 104 gps->gc_sf=NULL;
 105 gps->width=300;
 106 gps->height=300;
 107 gps->size=300;
 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_gps_paint_by_mode(gps);
 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 g_signal_connect(G_OBJECT(widget), "button_press_event", G_CALLBACK(gtk_gps_cb_button_press), NULL);
 143
 144 gps->context=gtk_widget_get_pango_context(widget);
 145 gps->layout=pango_layout_new(gps->context);
 146 gps->fontdesc=pango_font_description_new();
 147 pango_font_description_set_family(gps->fontdesc, "Sans Serif");
 148 pango_font_description_set_size(gps->fontdesc, 10*PANGO_SCALE);
 149 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 150 pango_layout_set_alignment(gps->layout, PANGO_ALIGN_CENTER);
 151
 152 return GTK_WIDGET(gps);
 153 }
 154
 155 static void
 156 gtk_gps_finalize(GObject *object)
 157 {
 158 GtkGps *gps;
 159
 160 g_return_if_fail(GTK_IS_GPS(object));
 161 gps=GTK_GPS(object);
 162
 163 if (GTK_WIDGET(object)->parent && GTK_WIDGET_MAPPED(object)) {
 164         gtk_widget_unmap(GTK_WIDGET(object));
 165 }
 166
 167 G_OBJECT_CLASS(gtk_gps_parent_class)->finalize(object);
 168 }
 169
 170 static void
 171 gtk_gps_size_request(GtkWidget  *widget, GtkRequisition *requisition)
 172 {
 173 GtkGps *gps;
 174
 175 g_printf("%s()\n", __PRETTY_FUNCTION__);
 176
 177 g_return_if_fail(GTK_IS_GPS(widget));
 178 g_return_if_fail(requisition!=NULL);
 179
 180 gps = GTK_GPS (widget);
 181
 182 requisition->width=300;
 183 requisition->height=300;
 184 gps->width=300;
 185 gps->height=300;
 186 gps->size=300;
 187 }
 188
 189 static void
 190 gtk_gps_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 191 {
 192 GtkGps *gps;
 193
 194 g_return_if_fail(GTK_IS_GPS(widget));
 195 g_return_if_fail(allocation!=NULL);
 196
 197 gps=GTK_GPS (widget);
 198
 199 widget->allocation = *allocation;
 200
 201 if (GTK_WIDGET_REALIZED (widget)) {
 202         gdk_window_move_resize (widget->window,
 203                 allocation->x, allocation->y,
 204                 allocation->width, allocation->height);
 205 }
 206
 207 gps->width=allocation->width;
 208 gps->height=allocation->height;
 209 gps->size=MIN(gps->width, gps->height);
 210
 211 gps->fs=gps->size/20;
 212 BOUND(gps->fs, 8, 20);
 213
 214 pango_font_description_set_size(gps->fontdesc, (gps->fs-1)*PANGO_SCALE);
 215 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 216 }
 217
 218 static void
 219 gtk_gps_realize (GtkWidget *widget)
 220 {
 221 GtkGps *gps;
 222 GdkColor color;
 223 GdkWindowAttr attributes;
 224 gint attributes_mask;
 225
 226 g_return_if_fail (GTK_IS_GPS(widget));
 227 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 228 gps=GTK_GPS(widget);
 229
 230 attributes.x=widget->allocation.x;
 231 attributes.y=widget->allocation.y;
 232 attributes.width=widget->allocation.width;
 233 attributes.height=widget->allocation.height;
 234 attributes.wclass=GDK_INPUT_OUTPUT;
 235 attributes.window_type=GDK_WINDOW_CHILD;
 236 attributes.event_mask=gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
 237 attributes.visual=gtk_widget_get_visual(widget);
 238 attributes.colormap=gtk_widget_get_colormap(widget);
 239
 240 attributes_mask=GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 241
 242 widget->window=gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
 243 widget->style=gtk_style_attach(widget->style, widget->window);
 244
 245 gdk_window_set_user_data(widget->window, widget);
 246 gtk_style_set_background(widget->style, widget->window, GTK_STATE_ACTIVE);
 247
 248 if (!gps->gc_s) {
 249         color.red=0;
 250         color.green=0;
 251         color.blue=0;
 252         gps->gc_s=gdk_gc_new(widget->window);
 253         gdk_gc_set_rgb_fg_color(gps->gc_s, &color);
 254 }
 255
 256 if (!gps->gc_sf) {
 257         color.red=0;
 258         color.green=0xffff;
 259         color.blue=0;
 260         gps->gc_sf=gdk_gc_new(widget->window);
 261         gdk_gc_set_rgb_fg_color(gps->gc_sf, &color);
 262 }
 263
 264 if (!gps->gc_w) {
 265         color.red=0xffff;
 266         color.green=0xffff;
 267         color.blue=0xffff;
 268         gps->gc_w=gdk_gc_new(widget->window);
 269         gdk_gc_set_rgb_fg_color(gps->gc_w, &color);
 270 }
 271 }
 272
 273 static void
 274 gtk_gps_paint_sky(GtkGps *gps)
 275 {
 276 GdkGC *gc;
 277 GtkWidget *widget;
 278 guint i, x, y, size, halfsize, xoffset, yoffset;
 279 guint x1, y1, x0, y0;
 280 gfloat tmp;
 281 gchar buffer[16];
 282 guint line[12]={0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330};
 283
 284 g_printf("%s()\n", __PRETTY_FUNCTION__);
 285
 286 widget=GTK_WIDGET(gps);
 287
 288 g_return_if_fail(gps->data);
 289
 290 if (!GTK_WIDGET_MAPPED(widget))
 291         return;
 292
 293 x0=0;
 294 y0=0;
 295
 296 size=gps->size-PADDING;
 297 halfsize=size/2;
 298 if (gps->width>gps->height) {
 299         xoffset=x0+(gps->width-gps->height)/2;
 300         yoffset=y0+5;
 301 } else {
 302         xoffset=x0+5;
 303         yoffset=y0+(gps->height-gps->width)/2;
 304 }
 305
 306 gtk_paint_flat_box (widget->style,
 307         widget->window,
 308         GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 309         NULL, widget, "trough", 0, 0,
 310         gps->width, gps->height);
 311
 312 /* 90 */
 313 gdk_draw_arc(widget->window,
 314              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 315              FALSE,
 316              xoffset + 2, yoffset + 2, size - 4, size - 4, 0, 64 * 360);
 317
 318 /* 60 */
 319 gdk_draw_arc(widget->window,
 320              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 321              FALSE,
 322              xoffset + size / 6, yoffset + size / 6,
 323              size / 6 * 4, size / 6 * 4, 0, 64 * 360);
 324
 325 /* 30 */
 326 gdk_draw_arc(widget->window,
 327              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 328              FALSE,
 329              xoffset + size / 6 * 2, yoffset + size / 6 * 2,
 330              size / 6 * 2, size / 6 * 2, 0, 64 * 360);
 331
 332 for (i = 0; i < 6; i++) {
 333         /* line */
 334         tmp = (line[i] * (1.f / 180.f)) * G_PI;
 335         gdk_draw_line(widget->window,
 336                       widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 337                       xoffset + halfsize + (halfsize - 2) * sinf(tmp),
 338                       yoffset + halfsize - (halfsize - 2) * cosf(tmp),
 339                       xoffset + halfsize - (halfsize - 2) * sinf(tmp),
 340                       yoffset + halfsize + (halfsize - 2) * cosf(tmp));
 341 }
 342
 343 if (size > 140) {
 344 for (i = 0; i < 12; i++) {
 345         tmp = (line[i] * (1.f / 180.f)) * G_PI;
 346         /* azimuth */
 347         if (line[i] == 0)
 348                 g_snprintf(buffer, 16, "N");
 349         else
 350                 g_snprintf(buffer, 16, "%d°", line[i]);
 351         pango_layout_set_text(gps->layout, buffer, -1);
 352         pango_layout_get_pixel_size(gps->layout, &x, &y);
 353         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 354                         (xoffset + halfsize + (halfsize - size / 12) * sinf(tmp)) - x / 2,
 355                         (yoffset + halfsize - (halfsize - size / 12) * cosf(tmp)) - y / 2,
 356                         gps->layout);
 357 }
 358
 359 /* elevation 30 */
 360 tmp = (30 * (1.f / 180.f)) * G_PI;
 361 g_snprintf(buffer, 16, "30°");
 362 pango_layout_set_text(gps->layout, buffer, -1);
 363 pango_layout_get_pixel_size(gps->layout, &x, &y);
 364 gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 365                 (xoffset + halfsize + size / 6 * 2 * sinf(tmp)) - x / 2,
 366                 (yoffset + halfsize - size / 6 * 2 * cosf(tmp)) - y / 2,
 367                 gps->layout);
 368
 369 /* elevation 60 */
 370 tmp = (30 * (1.f / 180.f)) * G_PI;
 371 g_snprintf(buffer, 16, "60°");
 372 pango_layout_set_text(gps->layout, buffer, -1);
 373 pango_layout_get_pixel_size(gps->layout, &x, &y);
 374 gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 375                 (xoffset + halfsize + size / 6 * sinf(tmp)) - x / 2,
 376                 (yoffset + halfsize - size / 6 * cosf(tmp)) - y / 2,
 377                 gps->layout);
 378 }
 379
 380 for (i=0;i<gps->data->satinview;i++) {
 381         /* Sat used or not */
 382         gc=(gps->data->sat[i].fix) ? gps->gc_sf : gps->gc_s;
 383
 384         tmp = (gps->data->sat[i].azimuth * (1.f / 180.f)) * G_PI;
 385         x = xoffset + halfsize + (90 - gps->data->sat[i].elevation) * halfsize / 90 * sinf(tmp);
 386         y = yoffset + halfsize - (90 - gps->data->sat[i].elevation) * halfsize / 90 * cosf(tmp);
 387
 388         gdk_draw_arc(widget->window, gc, TRUE, x-gps->fs, y-gps->fs, gps->fs+4, gps->fs+4, 0, 64 * 360);
 389
 390         g_snprintf(buffer, 6, "%02d", gps->data->sat[i].prn);
 391         pango_layout_set_text(gps->layout, buffer, -1);
 392         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 393         gdk_draw_layout(widget->window, gps->gc_w, x-gps->fs/2-x1/2, y-gps->fs/2-y1/2, gps->layout);
 394 }
 395
 396 return;
 397 }
 398
 399 static void
 400 gtk_gps_paint_signals(GtkGps *gps)
 401 {
 402 GdkGC *gc;
 403 GtkWidget *widget;
 404 guint step, i, snr_height, bymargin, xoffset, yoffset;
 405 guint x, y, x1, y1;
 406 gchar tmp[32];
 407
 408 widget=GTK_WIDGET(gps);
 409
 410 if (!GTK_WIDGET_MAPPED(widget))
 411         return;
 412
 413 xoffset=0;
 414 yoffset=0;
 415
 416 /* Bootom margin - 12% */
 417 bymargin = gps->height * 0.88f;
 418
 419 gtk_paint_flat_box (widget->style,
 420         widget->window,
 421         GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 422         NULL, widget, "trough", 0, 0,
 423         gps->width, gps->height);
 424
 425 /* Bottom line */
 426 gdk_draw_line(widget->window,
 427               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 428               xoffset + 5, yoffset + bymargin,
 429               xoffset + gps->width - 10 - 2, yoffset + bymargin);
 430 gdk_draw_line(widget->window,
 431               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 432               xoffset + 5, yoffset + bymargin - 1,
 433               xoffset + gps->width - 10 - 2, yoffset + bymargin - 1);
 434
 435 if (gps->data->satinview > 0) {
 436         /* Left margin - 5pix, Right margin - 5pix */
 437         step = (gps->width - 10) / gps->data->satinview;
 438
 439         for (i = 0; i < gps->data->satinview; i++) {
 440                 /* Sat used or not */
 441                 gc=(gps->data->sat[i].fix) ? gps->gc_sf : gps->gc_s;
 442
 443                 x = 5 + i * step;
 444                 snr_height = gps->data->sat[i].snr * gps->height * 0.78f / 100;
 445                 y = gps->height * 0.1f + (gps->height * 0.78f - snr_height);
 446
 447                 /* draw sat rectangle... */
 448                 gdk_draw_rectangle(widget->window,
 449                                    gc, TRUE,
 450                                    xoffset + x,
 451                                    yoffset + y, step - 2, snr_height);
 452
 453                 if (gps->data->sat[i].snr > 0) {
 454                         /* ...snr.. */
 455                         g_snprintf(tmp, 32, "%02d", gps->data->sat[i].snr);
 456                         pango_layout_set_text(gps->layout, tmp, 2);
 457                         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 458                         gdk_draw_layout(widget->window,
 459                                         widget->style->fg_gc[GTK_STATE_NORMAL],
 460                                         xoffset + x + ((step - 2) - x1) / 2,
 461                                                 yoffset + y - 15,
 462                                                 gps->layout);
 463                 }
 464
 465                 /* ...and sat number */
 466                 g_snprintf(tmp, 32, "%02d", gps->data->sat[i].prn);
 467                 pango_layout_set_text(gps->layout, tmp, 2);
 468                 pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 469                 gdk_draw_layout(widget->window,
 470                                 widget->style->fg_gc[GTK_STATE_NORMAL],
 471                                 xoffset + x + ((step - 2) - x1) / 2,
 472                                 yoffset + bymargin + 1,
 473                                 gps->layout);
 474         }
 475 }
 476
 477 return;
 478 }
 479
 480 static void
 481 gtk_gps_paint_by_mode(GtkGps *gps)
 482 {
 483 g_return_if_fail(GTK_IS_GPS(gps));
 484
 485 switch (gps->display_mode) {
 486         case GTK_GPS_MODE_SIGNAL:
 487                 gtk_gps_paint_signals(gps);
 488         break;
 489         case GTK_GPS_MODE_SKY:
 490         default:
 491                 gtk_gps_paint_sky(gps);
 492         break;
 493 }
 494 }
 495
 496 static gboolean
 497 gtk_gps_expose(GtkWidget *widget, GdkEventExpose *event)
 498 {
 499 GtkGps *gps;
 500
 501 g_return_val_if_fail(GTK_IS_GPS(widget), FALSE);
 502 g_return_val_if_fail(event != NULL, FALSE);
 503
 504 gps=GTK_GPS(widget);
 505 gtk_gps_paint_by_mode(gps);
 506 return TRUE;
 507 }
 508
 509 void
 510 gtk_gps_refresh(GtkWidget *widget)
 511 {
 512 GtkGps *gps;
 513
 514 g_return_if_fail(GTK_IS_GPS(widget));
 515
 516 gps=GTK_GPS(widget);
 517 gtk_gps_paint_by_mode(gps);
 518 }