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 gps->gc_w=NULL;
 101 gps->gc_s=NULL;
 102 gps->gc_sf=NULL;
 103 gps->width=300;
 104 gps->height=300;
 105 gps->size=300;
 106 }
 107
 108 static gboolean
 109 gtk_gps_cb_button_press(GtkWidget * widget, GdkEventButton * event)
 110 {
 111 GtkGps *gps;
 112
 113 gps=GTK_GPS(widget);
 114
 115 if (event->button==1) {
 116         switch (gps->display_mode) {
 117         case GTK_GPS_MODE_SKY:
 118                 gps->display_mode=GTK_GPS_MODE_SIGNAL;
 119         break;
 120         case GTK_GPS_MODE_SIGNAL:
 121         default:
 122                 gps->display_mode=GTK_GPS_MODE_SKY;
 123         break;
 124         }
 125 }
 126 gtk_widget_queue_draw_area(widget, 0, 0, gps->width, gps->height);
 127 return FALSE;
 128 }
 129
 130 GtkWidget*
 131 gtk_gps_new(GtkGpsMode display_mode, GpsData *data)
 132 {
 133 GtkGps *gps;
 134 GtkWidget *widget;
 135
 136 gps=gtk_type_new(gtk_gps_get_type ());
 137 gps->display_mode=display_mode;
 138 gps->data=data;
 139 widget=GTK_WIDGET(gps);
 140
 141 /* Allow switching if mode is combined */
 142 if (display_mode==GTK_GPS_MODE_COMBINED) {
 143         g_signal_connect(G_OBJECT(widget), "button_press_event", G_CALLBACK(gtk_gps_cb_button_press), NULL);
 144         display_mode=GTK_GPS_MODE_SKY;
 145 }
 146
 147 gps->context=gtk_widget_get_pango_context(widget);
 148 gps->layout=pango_layout_new(gps->context);
 149 gps->fontdesc=pango_font_description_new();
 150 pango_font_description_set_family(gps->fontdesc, "Sans Serif");
 151 pango_font_description_set_size(gps->fontdesc, 10*PANGO_SCALE);
 152 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 153 pango_layout_set_alignment(gps->layout, PANGO_ALIGN_CENTER);
 154
 155 return GTK_WIDGET(gps);
 156 }
 157
 158 static void
 159 gtk_gps_finalize(GObject *object)
 160 {
 161 GtkGps *gps;
 162
 163 g_return_if_fail(GTK_IS_GPS(object));
 164 gps=GTK_GPS(object);
 165
 166 if (GTK_WIDGET(object)->parent && GTK_WIDGET_MAPPED(object)) {
 167         gtk_widget_unmap(GTK_WIDGET(object));
 168 }
 169
 170 G_OBJECT_CLASS(gtk_gps_parent_class)->finalize(object);
 171 }
 172
 173 static void
 174 gtk_gps_size_request(GtkWidget  *widget, GtkRequisition *requisition)
 175 {
 176 GtkGps *gps;
 177
 178 g_return_if_fail(GTK_IS_GPS(widget));
 179 g_return_if_fail(requisition!=NULL);
 180
 181 gps = GTK_GPS (widget);
 182
 183 requisition->width=300;
 184 requisition->height=300;
 185 gps->width=300;
 186 gps->height=300;
 187 gps->size=300;
 188 }
 189
 190 static void
 191 gtk_gps_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 192 {
 193 GtkGps *gps;
 194
 195 g_return_if_fail(GTK_IS_GPS(widget));
 196 g_return_if_fail(allocation!=NULL);
 197
 198 gps=GTK_GPS (widget);
 199
 200 widget->allocation = *allocation;
 201
 202 if (GTK_WIDGET_REALIZED (widget)) {
 203         gdk_window_move_resize (widget->window,
 204                 allocation->x, allocation->y,
 205                 allocation->width, allocation->height);
 206 }
 207
 208 gps->width=allocation->width;
 209 gps->height=allocation->height;
 210 gps->size=MIN(gps->width, gps->height);
 211
 212 gps->fs=gps->size/22;
 213 BOUND(gps->fs, 10, 24);
 214
 215 pango_font_description_set_size(gps->fontdesc, (gps->fs-3)*PANGO_SCALE);
 216 pango_layout_set_font_description(gps->layout, gps->fontdesc);
 217 }
 218
 219 static void
 220 gtk_gps_realize (GtkWidget *widget)
 221 {
 222 GtkGps *gps;
 223 GdkColor color;
 224 GdkWindowAttr attributes;
 225 gint attributes_mask;
 226
 227 g_return_if_fail (GTK_IS_GPS(widget));
 228 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 229 gps=GTK_GPS(widget);
 230
 231 attributes.x=widget->allocation.x;
 232 attributes.y=widget->allocation.y;
 233 attributes.width=widget->allocation.width;
 234 attributes.height=widget->allocation.height;
 235 attributes.wclass=GDK_INPUT_OUTPUT;
 236 attributes.window_type=GDK_WINDOW_CHILD;
 237 attributes.event_mask=gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK;
 238 attributes.visual=gtk_widget_get_visual(widget);
 239 attributes.colormap=gtk_widget_get_colormap(widget);
 240
 241 attributes_mask=GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 242
 243 widget->window=gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);
 244 widget->style=gtk_style_attach(widget->style, widget->window);
 245
 246 gdk_window_set_user_data(widget->window, widget);
 247 gtk_style_set_background(widget->style, widget->window, GTK_STATE_ACTIVE);
 248
 249 if (!gps->gc_s) {
 250         color.red=0;
 251         color.green=0;
 252         color.blue=0;
 253         gps->gc_s=gdk_gc_new(widget->window);
 254         gdk_gc_set_rgb_fg_color(gps->gc_s, &color);
 255 }
 256
 257 if (!gps->gc_sf) {
 258         color.red=0;
 259         color.green=0xffff;
 260         color.blue=0;
 261         gps->gc_sf=gdk_gc_new(widget->window);
 262         gdk_gc_set_rgb_fg_color(gps->gc_sf, &color);
 263 }
 264
 265 if (!gps->gc_w) {
 266         color.red=0xffff;
 267         color.green=0xffff;
 268         color.blue=0xffff;
 269         gps->gc_w=gdk_gc_new(widget->window);
 270         gdk_gc_set_rgb_fg_color(gps->gc_w, &color);
 271 }
 272 }
 273
 274 static void
 275 gtk_gps_paint_sky(GtkGps *gps)
 276 {
 277 GdkGC *gc;
 278 GtkWidget *widget;
 279 guint i, x, y, size, halfsize, xoffset, yoffset;
 280 guint x1, y1, x0, y0;
 281 gfloat tmp;
 282 gchar buffer[16];
 283 guint line[12]={0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330};
 284
 285 widget=GTK_WIDGET(gps);
 286
 287 g_return_if_fail(gps->data);
 288
 289 if (!GTK_WIDGET_MAPPED(widget))
 290         return;
 291
 292 x0=0;
 293 y0=0;
 294
 295 size=gps->size-PADDING;
 296 halfsize=size/2;
 297 if (gps->width>gps->height) {
 298         xoffset=x0+(gps->width-gps->height)/2;
 299         yoffset=y0+5;
 300 } else {
 301         xoffset=x0+5;
 302         yoffset=y0+(gps->height-gps->width)/2;
 303 }
 304
 305 /* 90 */
 306 gdk_draw_arc(widget->window,
 307              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 308              FALSE,
 309              xoffset + 2, yoffset + 2, size - 4, size - 4, 0, 64 * 360);
 310
 311 /* 60 */
 312 gdk_draw_arc(widget->window,
 313              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 314              FALSE,
 315              xoffset + size / 6, yoffset + size / 6,
 316              size / 6 * 4, size / 6 * 4, 0, 64 * 360);
 317
 318 /* 30 */
 319 gdk_draw_arc(widget->window,
 320              widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 321              FALSE,
 322              xoffset + size / 6 * 2, yoffset + size / 6 * 2,
 323              size / 6 * 2, size / 6 * 2, 0, 64 * 360);
 324
 325 for (i = 0; i < 12; i++) {
 326         gfloat sint, cost;
 327
 328         tmp = (line[i] * (1.f / 180.f)) * G_PI;
 329         sint=sinf(tmp);
 330         cost=cosf(tmp);
 331         /* line */
 332         gdk_draw_line(widget->window,
 333                       widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 334                       xoffset + halfsize + (halfsize - 2) * sint,
 335                       yoffset + halfsize - (halfsize - 2) * cost,
 336                       xoffset + halfsize - (halfsize - 2) * sint,
 337                       yoffset + halfsize + (halfsize - 2) * cost);
 338
 339         /* Skip angle text if there is no space */
 340         if (size<100)
 341                 continue;
 342
 343         if (line[i] == 0)
 344                 g_snprintf(buffer, 16, "N");
 345         else
 346                 g_snprintf(buffer, 16, "%d°", line[i]);
 347         pango_layout_set_text(gps->layout, buffer, -1);
 348         pango_layout_get_pixel_size(gps->layout, &x, &y);
 349         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 350                         (xoffset + halfsize + (halfsize - size / 12) * sint) - x / 2,
 351                         (yoffset + halfsize - (halfsize - size / 12) * cost) - y / 2,
 352                         gps->layout);
 353
 354 }
 355
 356 if (size>100) {
 357         tmp = (30 * (1.f / 180.f)) * G_PI;
 358         /* elevation 30 */
 359         g_snprintf(buffer, 16, "30°");
 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 + size / 6 * 2 * sinf(tmp)) - x / 2,
 364                 (yoffset + halfsize - size / 6 * 2 * cosf(tmp)) - y / 2,
 365                 gps->layout);
 366
 367         /* elevation 60 */
 368         g_snprintf(buffer, 16, "60°");
 369         pango_layout_set_text(gps->layout, buffer, -1);
 370         pango_layout_get_pixel_size(gps->layout, &x, &y);
 371         gdk_draw_layout(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
 372                 (xoffset + halfsize + size / 6 * sinf(tmp)) - x / 2,
 373                 (yoffset + halfsize - size / 6 * cosf(tmp)) - y / 2,
 374                 gps->layout);
 375 }
 376
 377 for (i=0;i<gps->data->satinview;i++) {
 378         /* Sat used or not */
 379         gc=(gps->data->sat[i].fix==TRUE) ? gps->gc_sf : gps->gc_s;
 380
 381         tmp = (gps->data->sat[i].azimuth * (1.f / 180.f)) * G_PI;
 382         x = xoffset + halfsize + (90 - gps->data->sat[i].elevation) * halfsize / 90 * sinf(tmp);
 383         y = yoffset + halfsize - (90 - gps->data->sat[i].elevation) * halfsize / 90 * cosf(tmp);
 384
 385         gdk_draw_arc(widget->window, gc, TRUE, x-gps->fs, y-gps->fs, gps->fs+8, gps->fs+8, 0, 64 * 360);
 386
 387         g_snprintf(buffer, 6, "%02d", gps->data->sat[i].prn);
 388         pango_layout_set_text(gps->layout, buffer, -1);
 389         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 390         gdk_draw_layout(widget->window, gps->gc_w, x-gps->fs/2-x1/2+2, y-gps->fs/2-y1/2+2, gps->layout);
 391 }
 392
 393 return;
 394 }
 395
 396 static void
 397 gtk_gps_paint_signals(GtkGps *gps)
 398 {
 399 GdkGC *gc;
 400 GtkWidget *widget;
 401 guint step, i, snr_height, bymargin, xoffset, yoffset;
 402 guint x, y, x1, y1;
 403 gchar tmp[32];
 404
 405 widget=GTK_WIDGET(gps);
 406
 407 if (!GTK_WIDGET_MAPPED(widget))
 408         return;
 409
 410 xoffset=0;
 411 yoffset=0;
 412
 413 /* Bootom margin - 12% */
 414 bymargin = gps->height * 0.88f;
 415
 416 /* Bottom line */
 417 gdk_draw_line(widget->window,
 418               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 419               xoffset + 5, yoffset + bymargin,
 420               xoffset + gps->width - 10 - 2, yoffset + bymargin);
 421 gdk_draw_line(widget->window,
 422               widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 423               xoffset + 5, yoffset + bymargin - 1,
 424               xoffset + gps->width - 10 - 2, yoffset + bymargin - 1);
 425
 426 if (gps->data->satinview > 0) {
 427         /* Left margin - 5pix, Right margin - 5pix */
 428         step = (gps->width - 10) / gps->data->satinview;
 429
 430         for (i = 0; i < gps->data->satinview; i++) {
 431                 /* Sat used or not */
 432                 gc=(gps->data->sat[i].fix) ? gps->gc_sf : gps->gc_s;
 433
 434                 x = 5 + i * step;
 435                 snr_height = gps->data->sat[i].snr * gps->height * 0.78f / 100;
 436                 y = gps->height * 0.1f + (gps->height * 0.78f - snr_height);
 437
 438                 /* draw sat rectangle... */
 439                 gdk_draw_rectangle(widget->window,
 440                                    gc, TRUE,
 441                                    xoffset + x,
 442                                    yoffset + y, step - 2, snr_height);
 443
 444                 if (gps->data->sat[i].snr > 0) {
 445                         /* ...snr.. */
 446                         g_snprintf(tmp, 32, "%02d", gps->data->sat[i].snr);
 447                         pango_layout_set_text(gps->layout, tmp, 2);
 448                         pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 449                         gdk_draw_layout(widget->window,
 450                                         widget->style->fg_gc[GTK_STATE_NORMAL],
 451                                         xoffset + x + ((step - 2) - x1) / 2,
 452                                                 yoffset + y - 15,
 453                                                 gps->layout);
 454                 }
 455
 456                 /* ...and sat number */
 457                 g_snprintf(tmp, 32, "%02d", gps->data->sat[i].prn);
 458                 pango_layout_set_text(gps->layout, tmp, 2);
 459                 pango_layout_get_pixel_size(gps->layout, &x1, &y1);
 460                 gdk_draw_layout(widget->window,
 461                                 widget->style->fg_gc[GTK_STATE_NORMAL],
 462                                 xoffset + x + ((step - 2) - x1) / 2,
 463                                 yoffset + bymargin + 1,
 464                                 gps->layout);
 465         }
 466 }
 467
 468 return;
 469 }
 470
 471 static void
 472 gtk_gps_paint_by_mode(GtkGps *gps)
 473 {
 474 g_return_if_fail(GTK_IS_GPS(gps));
 475
 476 switch (gps->display_mode) {
 477         case GTK_GPS_MODE_SIGNAL:
 478                 gtk_gps_paint_signals(gps);
 479         break;
 480         case GTK_GPS_MODE_SKY:
 481         default:
 482                 gtk_gps_paint_sky(gps);
 483         break;
 484 }
 485 }
 486
 487 static gboolean
 488 gtk_gps_expose(GtkWidget *widget, GdkEventExpose *event)
 489 {
 490 GtkGps *gps;
 491
 492 g_return_val_if_fail(GTK_IS_GPS(widget), FALSE);
 493 g_return_val_if_fail(event != NULL, FALSE);
 494
 495 gps=GTK_GPS(widget);
 496 gtk_gps_paint_by_mode(gps);
 497 return TRUE;
 498 }
 499
 500 void
 501 gtk_gps_refresh(GtkWidget *widget)
 502 {
 503 GtkGps *gps;
 504
 505 g_return_if_fail(GTK_IS_GPS(widget));
 506
 507 gps=GTK_GPS(widget);
 508 gtk_widget_queue_draw_area(widget, 0, 0, gps->width, gps->height);
 509 }