2 * This file is part of mapper
4 * Copyright (C) 2007 Kaj-Michael Lang
5 * Copyright (C) 2006-2007 John Costigan.
7 * POI and GPS-Info code originally written by Cezary Jackiewicz.
9 * Default map data provided by http://www.openstreetmap.org/
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
36 #include <glib/gstdio.h>
42 #include "hildon-mapper.h"
53 #include "mapper-types.h"
54 #include "ui-common.h"
60 #include "map-download.h"
61 #include "announcements.h"
62 #include "gtkcompass.h"
65 #define DEBUG_MAP_TIME 1
67 /** The "base tile" is the upper-left tile in the pixmap. */
68 guint _base_tilex = -5;
69 guint _base_tiley = -5;
71 guint _zoom = 3; /* zoom level, from 0 to MAX_ZOOM. */
73 Point _min_center = { -1, -1 };
74 Point _max_center = { -1, -1 };
75 Point _focus = { -1, -1 };
76 Point _center = { -1, -1 }; /* current center location, X. */
78 CenterMode _center_mode = CENTER_LEAD;
81 static guint press[2] = { 0, 0 };
82 static guint release[2] = { 0, 0 };
83 static guint before[2] = { 0, 0 };
84 static guint map_drag_id = 0;
86 /** VARIABLES FOR ACCESSING THE LOCATION/BOUNDS OF THE CURRENT MARK. */
91 static gint mark_minx;
92 static gint mark_miny;
93 static gint mark_width;
94 static gint mark_height;
96 static GdkRectangle scale_rect;
97 static PangoContext *scale_context;
98 static PangoFontDescription *scale_font;
99 static PangoLayout *scale_layout;
101 static GdkGC *speed_gc1;
102 static GdkGC *speed_gc2;
103 static PangoContext *speed_context;
104 static PangoLayout *speed_layout;
105 static PangoFontDescription *speed_fontdesc;
107 static gint zoom_timeout_sid=0;
108 static gint map_mode=0;
109 static gboolean map_data_needs_refresh=FALSE;
111 osm_location map_loc = {NULL, NULL, NULL, FALSE, FALSE, 0, 0, 0.0, 0.0, 0 };
113 static GTimer *map_timer;
115 /* Tile max age, 1 week */
116 #define TILE_MAX_AGE (604800)
118 #define KM10KNOTS (5.39956803)
120 void map_render_paths();
121 void map_force_redraw();
122 void map_draw_position_icon(Position *pos);
124 static void map_update_location(gdouble lat, gdouble lon, gboolean force);
125 static void map_speed_draw(void);
126 static gboolean map_cb_after_realize(GtkWidget *map_widget, gpointer data);
127 static gboolean map_cb_configure(GtkWidget *widget, GdkEventConfigure *event);
128 static gboolean map_cb_expose(GtkWidget * widget, GdkEventExpose * event);
129 static gboolean map_cb_button_press(GtkWidget * widget, GdkEventButton * event);
130 static gboolean map_cb_button_release(GtkWidget * widget, GdkEventButton * event);
131 static gboolean map_cb_scroll_event(GtkWidget * widget, GdkEventScroll * event);
133 /******************************************************************************/
138 GtkWidget *map_widget;
140 map_widget=gtk_drawing_area_new();
141 g_signal_connect_after(G_OBJECT(map_widget), "realize", G_CALLBACK(map_cb_after_realize), NULL);
142 g_signal_connect(G_OBJECT(map_widget), "configure_event", G_CALLBACK(map_cb_configure), NULL);
143 map_timer=g_timer_new();
148 map_cb_after_realize(GtkWidget *map_widget, gpointer data)
152 _map_pixmap=gdk_pixmap_new(map_widget->window, BUF_WIDTH_PIXELS, BUF_HEIGHT_PIXELS, -1);
154 scale_context=gtk_widget_get_pango_context(map_widget);
155 scale_layout=pango_layout_new(scale_context);
156 scale_font=pango_font_description_new();
157 pango_font_description_set_size(scale_font, 12 * PANGO_SCALE);
158 pango_layout_set_font_description(scale_layout, scale_font);
161 speed_gc1=gdk_gc_new(map_widget->window);
165 gdk_gc_set_rgb_fg_color(speed_gc1, &color);
169 speed_gc2=gdk_gc_new(map_widget->window);
170 gdk_gc_set_rgb_fg_color(speed_gc2, &color);
171 speed_context=gtk_widget_get_pango_context(map_widget);
172 speed_layout=pango_layout_new(speed_context);
173 speed_fontdesc=pango_font_description_new();
174 pango_font_description_set_size(speed_fontdesc, 48 * PANGO_SCALE);
175 pango_layout_set_font_description(speed_layout, speed_fontdesc);
176 pango_layout_set_alignment(speed_layout, PANGO_ALIGN_CENTER);
179 g_signal_connect(G_OBJECT(map_widget), "expose_event", G_CALLBACK(map_cb_expose), NULL);
180 g_signal_connect(G_OBJECT(map_widget), "button_press_event", G_CALLBACK(map_cb_button_press), NULL);
181 g_signal_connect(G_OBJECT(map_widget), "button_release_event",G_CALLBACK(map_cb_button_release), NULL);
182 g_signal_connect(G_OBJECT(map_widget), "scroll_event", G_CALLBACK(map_cb_scroll_event), NULL);
184 gtk_widget_add_events(map_widget, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
185 | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
187 map_poi_init(map_widget);
193 map_cb_configure(GtkWidget *widget, GdkEventConfigure *event)
196 _screen_width_pixels = _map_widget->allocation.width;
197 _screen_height_pixels = _map_widget->allocation.height;
198 _screen_grids_halfwidth = pixel2grid(_screen_width_pixels) / 2;
199 _screen_grids_halfheight = pixel2grid(_screen_height_pixels) / 2;
201 /* Set scale_rect. */
202 scale_rect.x = (_screen_width_pixels - SCALE_WIDTH) / 2;
203 scale_rect.width = SCALE_WIDTH;
205 MACRO_RECALC_FOCUS_BASE();
206 MACRO_RECALC_FOCUS_SIZE();
208 _min_center.unitx = pixel2unit(grid2pixel(_screen_grids_halfwidth));
209 _min_center.unity = pixel2unit(grid2pixel(_screen_grids_halfheight));
210 _max_center.unitx = WORLD_SIZE_UNITS - grid2unit(_screen_grids_halfwidth) - 1;
211 _max_center.unity = WORLD_SIZE_UNITS - grid2unit(_screen_grids_halfheight) - 1;
217 * Draw the current mark (representing the current GPS location) onto
218 * _map_widget. This method does not queue the draw area.
221 map_draw_mark(Gps *gps)
223 gdk_draw_arc(_map_widget->window, gps->io.conn == RCVR_FIXED ? _gc[COLORABLE_MARK] : _gc[COLORABLE_MARK_OLD], FALSE,
224 mark_x1 - _draw_width, mark_y1 - _draw_width, 2 * _draw_width, 2 * _draw_width, 0, 360 * 64);
225 gdk_draw_line(_map_widget->window, gps->io.conn == RCVR_FIXED ? (_show_velvec ? _gc[COLORABLE_MARK_VELOCITY] : _gc[COLORABLE_MARK]) : _gc[COLORABLE_MARK_OLD],
226 mark_x1, mark_y1, mark_x2, mark_y2);
230 * "Set" the mark, which translates the current GPS position into on-screen
231 * units in preparation for drawing the mark with map_draw_mark().
234 map_set_mark(GpsData *gps)
236 mark_x1 = unit2x(gps->unitx);
237 mark_y1 = unit2y(gps->unity);
238 mark_x2 = mark_x1 + (_show_velvec ? gps->vel_offsetx : 0);
239 mark_y2 = mark_y1 + (_show_velvec ? gps->vel_offsety : 0);
240 mark_minx = MIN(mark_x1, mark_x2) - (2 * _draw_width);
241 mark_miny = MIN(mark_y1, mark_y2) - (2 * _draw_width);
242 mark_width = abs(mark_x1 - mark_x2) + (4 * _draw_width);
243 mark_height = abs(mark_y1 - mark_y2) + (4 * _draw_width);
247 * Do an in-place scaling of a pixbuf's pixels at the given ratio from the
248 * given source location. It would have been nice if gdk_pixbuf provided
249 * this method, but I guess it's not general-purpose enough.
252 map_pixbuf_scale_inplace(GdkPixbuf * pixbuf, guint ratio_p2, guint src_x, guint src_y)
254 guint dest_x = 0, dest_y = 0, dest_dim = TILE_SIZE_PIXELS;
255 guint rowstride = gdk_pixbuf_get_rowstride(pixbuf);
256 guint n_channels = gdk_pixbuf_get_n_channels(pixbuf);
257 guchar *pixels = gdk_pixbuf_get_pixels(pixbuf);
259 /* Sweep through the entire dest area, copying as necessary, but
260 * DO NOT OVERWRITE THE SOURCE AREA. We'll copy it afterward. */
262 guint src_dim = dest_dim >> ratio_p2;
263 guint src_endx = src_x - dest_x + src_dim;
266 for (y = dest_dim - 1; y >= 0; y--) {
267 guint src_offset_y, dest_offset_y;
269 src_offset_y = (src_y + (y >> ratio_p2)) * rowstride;
270 dest_offset_y = (dest_y + y) * rowstride;
273 if ((unsigned)(dest_y + y - src_y) < src_dim && (unsigned)(dest_x + x - src_x) < src_dim)
276 for (; x >= 0; x--) {
277 guint src_offset, dest_offset, i;
279 src_offset = src_offset_y + (src_x + (x >> ratio_p2)) * n_channels;
280 dest_offset = dest_offset_y + (dest_x + x) * n_channels;
282 pixels[dest_offset] = pixels[src_offset];
283 for (i = n_channels - 1; i; i--)
284 pixels[dest_offset + i] = pixels[src_offset + i];
286 if ((unsigned)(dest_y + y - src_y) < src_dim && x == src_endx)
291 /* Reuse src_dim and src_endx to store new src_x and src_y. */
292 src_dim = src_x + ((src_x - dest_x) >> ratio_p2);
293 src_endx = src_y + ((src_y - dest_y) >> ratio_p2);
299 while ((dest_dim >>= ratio_p2) > 1);
303 * Trim pixbufs that are bigger than tiles. (Those pixbufs result, when
304 * captions should be cut off.)
307 pixbuf_trim(GdkPixbuf * pixbuf)
309 GdkPixbuf *mpixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf),
310 8, TILE_SIZE_PIXELS, TILE_SIZE_PIXELS);
312 gdk_pixbuf_copy_area(pixbuf,
313 (gdk_pixbuf_get_width(pixbuf) - TILE_SIZE_PIXELS) / 2,
314 (gdk_pixbuf_get_height(pixbuf) - TILE_SIZE_PIXELS) / 2,
316 TILE_SIZE_PIXELS, mpixbuf, 0, 0);
318 g_object_unref(pixbuf);
323 map_tile_load(guint tilex, guint tiley, gint zoff, gboolean download)
326 GError *error = NULL;
327 gchar buffer[BUFFER_SIZE];
331 g_snprintf(buffer, sizeof(buffer), "%s/%u/%u/%u.jpg", _curr_repo->cache_dir, _zoom + zoff, (tilex >> zoff), (tiley >> zoff));
333 pixbuf=gdk_pixbuf_new_from_file(buffer, &error);
334 if (error || !pixbuf) {
337 if (_auto_download && _curr_repo->type != REPOTYPE_NONE && !((_zoom + zoff - (_curr_repo->double_size ? 1 : 0)) % _curr_repo->dl_zoom_steps)) {
339 map_initiate_download(tilex >> zoff, tiley >> zoff, _zoom + zoff, -INITIAL_DOWNLOAD_RETRIES);
345 /* Check tile age, if file date is ower a week old, redownload if autodownload enabled */
346 se=stat(buffer, &tstat);
350 if (t-tstat.st_mtime>TILE_MAX_AGE) {
351 if (_auto_download && _curr_repo->type != REPOTYPE_NONE && !((_zoom + zoff - (_curr_repo->double_size ? 1 : 0)) % _curr_repo->dl_zoom_steps)) {
353 g_printf("Tile: %s is old, re-downloading\n", buffer);
354 map_initiate_download(tilex >> zoff, tiley >> zoff, _zoom + zoff, -INITIAL_DOWNLOAD_RETRIES);
364 map_render_tile(guint tilex, guint tiley, guint destx, guint desty, gboolean fast_fail)
366 GdkPixbuf *pixbuf=NULL;
369 if (tilex<_world_size_tiles && tiley<_world_size_tiles) {
370 /* The tile is possible. */
371 for (zoff = (_curr_repo->double_size ? 1 : 0); !pixbuf && (_zoom + zoff) <= MAX_ZOOM && zoff <= TILE_SIZE_P2; zoff += 1) {
372 pixbuf=map_tile_load(tilex, tiley, zoff, !fast_fail);
377 /* Check if we need to trim. */
378 if (gdk_pixbuf_get_width(pixbuf) != TILE_SIZE_PIXELS || gdk_pixbuf_get_height(pixbuf) != TILE_SIZE_PIXELS)
379 pixbuf = pixbuf_trim(pixbuf);
381 /* Check if we need to blit. */
383 map_pixbuf_scale_inplace(pixbuf, zoff,
384 (tilex - ((tilex >> zoff) << zoff)) << (TILE_SIZE_P2 - zoff),
385 (tiley - ((tiley >> zoff) << zoff)) << (TILE_SIZE_P2 - zoff));
392 gdk_draw_pixbuf(_map_pixmap, _gc[COLORABLE_MARK], pixbuf, 0, 0, destx, desty, TILE_SIZE_PIXELS, TILE_SIZE_PIXELS, GDK_RGB_DITHER_NONE, 0, 0);
393 g_object_unref(pixbuf);
396 gdk_draw_rectangle(_map_pixmap, _map_widget->style->black_gc, TRUE, destx, desty, TILE_SIZE_PIXELS, TILE_SIZE_PIXELS);
400 map_render_data(void)
402 /* Don't update if dragging, too much lag */
407 map_draw_position_icon(&_home);
409 map_render_all_pois();
415 * Force a redraw of the entire _map_pixmap, including fetching the
416 * background maps from disk and redrawing the tracks on top of them.
419 map_force_redraw(void)
422 #ifdef DEBUG_MAP_TIME
425 g_timer_start(map_timer);
427 for (new_y = 0; new_y < BUF_HEIGHT_TILES; ++new_y)
428 for (new_x = 0; new_x < BUF_WIDTH_TILES; ++new_x) {
429 map_render_tile(_base_tilex + new_x,
431 new_x * TILE_SIZE_PIXELS,
432 new_y * TILE_SIZE_PIXELS, FALSE);
434 #ifdef DEBUG_MAP_TIME
435 g_timer_stop(map_timer);
436 g_printf("Full redraw: %f sec\n", g_timer_elapsed(map_timer, &tms));
439 MACRO_QUEUE_DRAW_AREA();
443 * Set the current zoom level. If the given zoom level is the same as the
444 * current zoom level, or if the new zoom is invalid
445 * (not MIN_ZOOM <= new_zoom < MAX_ZOOM), then this method does nothing.
448 map_set_zoom(guint new_zoom)
450 /* Note that, since new_zoom is a guint and MIN_ZOOM is 0, this if
451 * condition also checks for new_zoom >= MIN_ZOOM. */
452 if (new_zoom > (MAX_ZOOM - 1))
454 if (new_zoom == _zoom)
457 _zoom = new_zoom / _curr_repo->view_zoom_steps * _curr_repo->view_zoom_steps;
458 _world_size_tiles = unit2tile(WORLD_SIZE_UNITS);
460 /* If we're leading, update the center to reflect new zoom level. */
461 MACRO_RECALC_CENTER(_gps->data, _center.unitx, _center.unity);
463 /* Update center bounds to reflect new zoom level. */
464 _min_center.unitx = pixel2unit(grid2pixel(_screen_grids_halfwidth));
465 _min_center.unity = pixel2unit(grid2pixel(_screen_grids_halfheight));
466 _max_center.unitx = WORLD_SIZE_UNITS - grid2unit(_screen_grids_halfwidth) - 1;
467 _max_center.unity = WORLD_SIZE_UNITS - grid2unit(_screen_grids_halfheight) - 1;
469 BOUND(_center.unitx, _min_center.unitx, _max_center.unitx);
470 BOUND(_center.unity, _min_center.unity, _max_center.unity);
472 _base_tilex = grid2tile((gint) pixel2grid((gint) unit2pixel((gint) _center.unitx)) - (gint) _screen_grids_halfwidth);
473 _base_tiley = grid2tile(pixel2grid(unit2pixel(_center.unity)) - _screen_grids_halfheight);
475 /* New zoom level, so we can't reuse the old buffer's pixels. */
476 /* Update state variables. */
477 MACRO_RECALC_OFFSET();
478 MACRO_RECALC_FOCUS_BASE();
479 MACRO_RECALC_FOCUS_SIZE();
481 map_set_mark(&_gps->data);
486 * Center the view on the given unitx/unity.
489 map_center_unit(guint new_center_unitx, guint new_center_unity)
491 gint new_base_tilex, new_base_tiley;
493 guint j, k, base_new_x, base_old_x, old_x, old_y, iox, ioy;
495 /* Assure that _center.unitx/y are bounded. */
496 BOUND(new_center_unitx, _min_center.unitx, _max_center.unitx);
497 BOUND(new_center_unity, _min_center.unity, _max_center.unity);
499 _center.unitx = new_center_unitx;
500 _center.unity = new_center_unity;
502 new_base_tilex = grid2tile((gint) pixel2grid((gint)unit2pixel((gint) _center.unitx)) - (gint)_screen_grids_halfwidth);
503 new_base_tiley = grid2tile(pixel2grid(unit2pixel(_center.unity)) - _screen_grids_halfheight);
505 /* Same zoom level, so it's likely that we can reuse some of the old
506 * buffer's pixels. */
508 if (new_base_tilex != _base_tilex || new_base_tiley != _base_tiley) {
509 /* If copying from old parts to new parts, we need to make sure we
510 * don't overwrite the old parts when copying, so set up new_x,
511 * new_y, old_x, old_y, iox, and ioy with that in mind. */
512 if (new_base_tiley < _base_tiley) {
513 /* New is lower than old - start at bottom and go up. */
514 new_y = BUF_HEIGHT_TILES - 1;
517 /* New is higher than old - start at top and go down. */
521 if (new_base_tilex < _base_tilex) {
522 /* New is righter than old - start at right and go left. */
523 base_new_x = BUF_WIDTH_TILES - 1;
526 /* New is lefter than old - start at left and go right. */
531 /* Iterate over the y tile values. */
532 old_y = new_y + new_base_tiley - _base_tiley;
533 base_old_x = base_new_x + new_base_tilex - _base_tilex;
534 _base_tilex = new_base_tilex;
535 _base_tiley = new_base_tiley;
536 for (j = 0; j < BUF_HEIGHT_TILES; ++j, new_y += ioy, old_y += ioy) {
539 /* Iterate over the x tile values. */
540 for (k = 0; k < BUF_WIDTH_TILES; ++k, new_x += iox, old_x += iox) {
541 /* Can we get this grid block from the old buffer?. */
542 if (old_x >= 0 && old_x < BUF_WIDTH_TILES && old_y >= 0 && old_y < BUF_HEIGHT_TILES) {
543 /* Copy from old buffer to new buffer. */
544 gdk_draw_drawable(_map_pixmap,
547 old_x * TILE_SIZE_PIXELS,
548 old_y * TILE_SIZE_PIXELS,
549 new_x * TILE_SIZE_PIXELS,
550 new_y * TILE_SIZE_PIXELS,
554 map_render_tile(new_base_tilex + new_x,
555 new_base_tiley + new_y,
556 new_x * TILE_SIZE_PIXELS,
557 new_y * TILE_SIZE_PIXELS,
565 MACRO_RECALC_OFFSET();
566 MACRO_RECALC_FOCUS_BASE();
568 map_set_mark(&_gps->data);
569 MACRO_QUEUE_DRAW_AREA();
573 * Pan the view by the given number of units in the X and Y directions.
576 map_pan(gint delta_unitx, gint delta_unity)
578 if (_center_mode > 0)
579 set_action_activate("autocenter_none", TRUE);
581 map_center_unit(_center.unitx + delta_unitx, _center.unity + delta_unity);
585 * Helper to center map on given lat/lon
588 map_center_latlon(gdouble lat, gdouble lon)
592 latlon2unit(lat, lon, unitx, unity);
593 map_center_unit(unitx, unity);
597 * Helper to goto given point and update location
601 map_goto_position(Position *pos)
603 if (pos->valid==FALSE)
606 _center_mode=CENTER_MANUAL;
607 map_center_latlon(pos->lat, pos->lon);
608 map_set_autozoom(FALSE, 0);
609 g_idle_add_full(G_PRIORITY_HIGH_IDLE,(GSourceFunc)map_update_location_from_center, NULL, NULL);
614 * Initiate a move of the mark from the old location to the current
615 * location. This function queues the draw area of the old mark (to force
616 * drawing of the background map), then updates the mark, then queus the
617 * draw area of the new mark.
622 /* Just queue the old and new draw areas. */
623 gtk_widget_queue_draw_area(_map_widget,
624 mark_minx<0 ? 0 : mark_minx,
625 mark_miny<0 ? 0 : mark_miny,
626 mark_width, mark_height);
627 map_set_mark(&_gps->data);
628 gtk_widget_queue_draw_area(_map_widget,
629 mark_minx<0 ? 0 : mark_minx,
630 mark_miny<0 ? 0 : mark_miny,
631 mark_width, mark_height);
635 map_update_location_from_gps(Gps *gps)
638 map_update_location(gps->data.lat, gps->data.lon, FALSE);
643 map_update_location_from_center(void)
646 /* Force re-validation of place if user is clicking around */
648 /* XXX: hmm, not the right place for this */
650 if (_gps->fix==FIX_NOFIX) {
651 _gps->data.unitx=_center.unitx;
652 _gps->data.unity=_center.unity;
653 unit2latlon(_gps->data.unitx, _gps->data.unity, _gps->data.lat, _gps->data.lon);
656 unit2latlon(_center.unitx, _center.unity, lat, lon);
657 map_update_location(lat, lon, TRUE);
662 * Draw given pixbuf on map, centered on x,y
665 map_draw_pixbuf(guint unitx, guint unity, GdkPixbuf *p)
668 x = unit2bufx(unitx);
669 y = unit2bufy(unity);
671 gdk_draw_pixbuf(_map_pixmap, _gc[COLORABLE_POI],
673 x - gdk_pixbuf_get_width(p) / 2,
674 y - gdk_pixbuf_get_height(p) / 2,
675 -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
679 * Draw an icon on given Position.
681 * XXX: don't hardcode as home.png !
684 map_draw_position_icon(Position *pos)
689 latlon2unit(pos->lat, pos->lon, x, y);
693 if ((x1 > BUF_WIDTH_PIXELS) || (y1 > BUF_HEIGHT_PIXELS))
696 p=gdk_pixbuf_new_from_file(DATADIR "/pixmaps/mapper/home.png", NULL);
698 map_draw_pixbuf(x,y,p);
705 * Make sure the mark is up-to-date. This function triggers a panning of
706 * the view if the mark is appropriately close to the edge of the view.
709 map_refresh_mark(void)
711 guint new_center_unitx;
712 guint new_center_unity;
714 MACRO_RECALC_CENTER(_gps->data, new_center_unitx, new_center_unity);
716 if ((new_center_unitx - _focus.unitx) < _focus_unitwidth && (new_center_unity - _focus.unity) < _focus_unitheight)
717 /* We're not changing the view - just move the mark. */
720 map_center_unit(new_center_unitx, new_center_unity);
722 /* Draw speed info */
727 g_idle_add_full(G_PRIORITY_HIGH_IDLE,(GSourceFunc)map_update_location_from_gps, _gps, NULL);
731 * Render a single track line to _map_pixmap. If either point on the line
732 * is a break (defined as unity == 0), a circle is drawn at the other point.
733 * IT IS AN ERROR FOR BOTH POINTS TO INDICATE A BREAK.
736 map_render_segment(GdkGC * gc_norm, GdkGC * gc_alt, guint unitx1, guint unity1, guint unitx2, guint unity2)
740 x2 = unit2bufx(unitx2);
741 y2 = unit2bufy(unity2);
742 /* Make sure this circle will be visible. */
743 if ((x2 < BUF_WIDTH_PIXELS) && (y2 < BUF_HEIGHT_PIXELS))
744 gdk_draw_arc(_map_pixmap, gc_alt, FALSE, /* FALSE: not filled. */
745 x2 - _draw_width, y2 - _draw_width, 2 * _draw_width, 2 * _draw_width, 0, /* start at 0 degrees. */
747 } else if (!unity2) {
749 x1 = unit2bufx(unitx1);
750 y1 = unit2bufy(unity1);
751 /* Make sure this circle will be visible. */
752 if ((x1 < BUF_WIDTH_PIXELS) && ((unsigned)y1 < BUF_HEIGHT_PIXELS))
753 gdk_draw_arc(_map_pixmap, gc_alt, FALSE, /* FALSE: not filled. */
754 x1 - _draw_width, y1 - _draw_width, 2 * _draw_width, 2 * _draw_width, 0, /* start at 0 degrees. */
758 x1 = unit2bufx(unitx1);
759 y1 = unit2bufy(unity1);
760 x2 = unit2bufx(unitx2);
761 y2 = unit2bufy(unity2);
762 /* Make sure this line could possibly be visible. */
763 if (!((x1 > BUF_WIDTH_PIXELS && x2 > BUF_WIDTH_PIXELS)
764 || (x1 < 0 && x2 < 0)
765 || (y1 > BUF_HEIGHT_PIXELS && y2 > BUF_HEIGHT_PIXELS)
766 || (y1 < 0 && y2 < 0)))
767 gdk_draw_line(_map_pixmap, gc_norm, x1, y1, x2, y2);
772 * Render all track data onto the _map_pixmap. Note that this does not
773 * clear the pixmap of previous track data (use map_force_redraw() for
774 * that), and also note that this method does not queue any redraws, so it
775 * is up to the caller to decide which part of the track really needs to be
779 map_render_path(Path * path, GdkGC ** gc)
784 /* gc is a pointer to the first GC to use (for plain points). (gc + 1)
785 * is a pointer to the GC to use for waypoints, and (gc + 2) is a pointer
786 * to the GC to use for breaks. */
788 /* else there is a route to draw. */
789 for (curr = path->head, wcurr = path->whead; curr++ != path->tail;) {
790 /* Draw the line from (curr - 1) to (curr). */
791 map_render_segment(gc[0], gc[2],
792 curr[-1].unitx, curr[-1].unity, curr->unitx,
795 /* Now, check if curr is a waypoint. */
796 if (wcurr && wcurr <= path->wtail && wcurr->point == curr) {
797 guint x1 = unit2bufx(wcurr->point->unitx);
798 guint y1 = unit2bufy(wcurr->point->unity);
799 if ((x1 < BUF_WIDTH_PIXELS)
800 && (y1 < BUF_HEIGHT_PIXELS)) {
801 gdk_draw_arc(_map_pixmap, gc[1], FALSE, /* FALSE: not filled. */
802 x1 - _draw_width, y1 - _draw_width, 2 * _draw_width, 2 * _draw_width, 0, /* start at 0 degrees. */
811 map_render_paths(void)
813 if ((_show_tracks & ROUTES_MASK) && _route.head != _route.tail) {
814 map_render_path(&_route, _gc + COLORABLE_ROUTE);
816 /* Now, draw the next waypoint on top of all other waypoints. */
818 guint x1 = unit2bufx(_next_way->point->unitx);
819 guint y1 = unit2bufy(_next_way->point->unity);
821 if ((x1 < BUF_WIDTH_PIXELS) && (y1 < BUF_HEIGHT_PIXELS)) {
822 /* Draw the next waypoint as a break. */
823 gdk_draw_arc(_map_pixmap, _gc[COLORABLE_ROUTE_BREAK], FALSE, /* FALSE: not filled. */
824 x1 - _draw_width, y1 - _draw_width, 4 * _draw_width, 4 * _draw_width, 0, /* start at 0 degrees. */
829 if (_show_tracks & TRACKS_MASK)
830 map_render_path(&_track, _gc + COLORABLE_TRACK);
838 map_follow_move_cb(GtkWidget *widget, GdkEventMotion *event, gpointer data)
840 GdkModifierType state;
845 if (!(event->state & GDK_BUTTON1_MASK))
848 if (event->is_hint) {
849 gdk_window_get_pointer(event->window, &xx, &yy, &state);
850 state = event->state;
854 state = event->state;
857 unitx = x2unit((gint) (xx - before[0]));
858 unity = y2unit((gint) (yy - before[1]));
859 cx = unit2x(_center.unitx);
860 cy = unit2y(_center.unity);
862 map_center_unit(x2unit((gint) (cx - (xx - before[0]))), y2unit((gint) (cy - (yy - before[1]))));
863 map_data_needs_refresh=TRUE;
871 map_key_zoom_timeout(void)
873 if (_key_zoom_new < _zoom) {
874 /* We're currently zooming in (_zoom is decreasing). */
875 guint test = _key_zoom_new - _curr_repo->view_zoom_steps;
877 _key_zoom_new = test;
881 /* We're currently zooming out (_zoom is increasing). */
882 guint test = _key_zoom_new + _curr_repo->view_zoom_steps;
884 _key_zoom_new = test;
893 map_information_text(guint x, guint y, GdkGC *gc, gchar *msg)
897 pango_layout_set_text(speed_layout, msg, -1);
898 pango_layout_get_pixel_size(speed_layout, &width, &height);
899 gtk_widget_queue_draw_area(_map_widget, x - 5, y - 5, width * 3 + 15, height + 5);
900 gdk_window_process_all_updates();
901 gdk_draw_layout(_map_widget->window, gc, x, y, speed_layout);
911 cur_speed = _gps->data.speed * UNITS_CONVERT[_units];
912 gc=(cur_speed > _speed_limit) ? speed_gc1 : speed_gc2;
913 buffer = g_strdup_printf("%0.0f", cur_speed);
914 map_information_text(10, 10, gc, buffer);
919 map_scale_draw(GdkEventExpose *event)
923 gdouble lat1, lon1, lat2, lon2;
926 pango_layout_set_text(scale_layout, "0", -1);
927 pango_layout_get_pixel_size(scale_layout, NULL, &scale_rect.height);
928 scale_rect.y = _screen_height_pixels - scale_rect.height - 1;
930 gdk_rectangle_intersect(&event->area, &scale_rect, &event->area);
932 if (event->area.width && event->area.height) {
933 gdk_draw_rectangle(_map_widget->window,
934 _map_widget->style->bg_gc[GTK_WIDGET_STATE(_map_widget)],
935 TRUE, scale_rect.x, scale_rect.y,
938 gdk_draw_rectangle(_map_widget->window,
939 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
940 FALSE, scale_rect.x, scale_rect.y,
944 /* Now calculate and draw the distance. */
945 unit2latlon(_center.unitx - pixel2unit(SCALE_WIDTH / 2 - 4), _center.unity, lat1, lon1);
946 unit2latlon(_center.unitx + pixel2unit(SCALE_WIDTH / 2 - 4), _center.unity, lat2, lon2);
947 distance=calculate_distance(lat1, lon1, lat2, lon2) * UNITS_CONVERT[_units];
950 g_snprintf(buffer, sizeof(buffer), "%0.2f %s", distance, UNITS_TEXT[_units]);
951 else if (distance < 10.f)
952 g_snprintf(buffer, sizeof(buffer), "%0.1f %s", distance, UNITS_TEXT[_units]);
954 g_snprintf(buffer, sizeof(buffer), "%0.f %s", distance, UNITS_TEXT[_units]);
956 pango_layout_set_text(scale_layout, buffer, -1);
957 pango_layout_get_pixel_size(scale_layout, &width, NULL);
959 /* Draw the layout itself. */
960 gdk_draw_layout(_map_widget->window,
961 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
962 scale_rect.x + (scale_rect.width - width) / 2,
963 scale_rect.y, scale_layout);
965 /* Draw little hashes on the ends. */
966 gdk_draw_line(_map_widget->window,
967 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
969 scale_rect.y + scale_rect.height / 2 - 4,
971 scale_rect.y + scale_rect.height / 2 + 4);
972 gdk_draw_line(_map_widget->window,
973 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
975 scale_rect.y + scale_rect.height / 2,
976 scale_rect.x + (scale_rect.width - width) / 2 - 4,
977 scale_rect.y + scale_rect.height / 2);
978 gdk_draw_line(_map_widget->window,
979 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
980 scale_rect.x + scale_rect.width - 4,
981 scale_rect.y + scale_rect.height / 2 - 4,
982 scale_rect.x + scale_rect.width - 4,
983 scale_rect.y + scale_rect.height / 2 + 4);
984 gdk_draw_line(_map_widget->window,
985 _map_widget->style->fg_gc[GTK_WIDGET_STATE(_map_widget)],
986 scale_rect.x + scale_rect.width - 4,
987 scale_rect.y + scale_rect.height / 2,
988 scale_rect.x + (scale_rect.width + width) / 2 + 4,
989 scale_rect.y + scale_rect.height / 2);
994 map_cb_expose(GtkWidget * widget, GdkEventExpose * event)
996 gdk_draw_drawable(GDK_DRAWABLE(_map_widget->window),
999 event->area.x + _offsetx, event->area.y + _offsety,
1000 event->area.x, event->area.y,
1001 event->area.width, event->area.height);
1002 map_draw_mark(_gps);
1004 /* Draw scale, if necessary. */
1006 map_scale_draw(event);
1022 if ((nzoom > 0) && (nzoom < MAX_ZOOM - 1)) {
1023 map_set_zoom(nzoom);
1043 map_autozoomer(void)
1045 static gfloat z=5.0;
1049 if (zoom_timeout_sid==0)
1052 z=(z+_gps->data.speed+1)/5;
1053 if (z>5) z=5.0; else if (z<1) z=1.0;
1056 g_printf("Setting autozoom to: %f %d S:%f\n", z, iz, _gps->data.speed);
1069 map_set_autozoom(gboolean az, gfloat speed)
1072 MACRO_BANNER_SHOW_INFO(_window, "Autozoom enabled");
1073 zoom_timeout_sid=g_timeout_add(speed<5 ? 2000 : 5000, (GSourceFunc) map_autozoomer, NULL);
1076 if (zoom_timeout_sid) {
1077 g_source_remove(zoom_timeout_sid);
1079 MACRO_BANNER_SHOW_INFO(_window, "Autozoom disabled");
1087 map_draw_route(gint x, gint y)
1089 cmenu_route_add_way(x, y);
1093 map_draw_track(gint x, gint y)
1095 _gps->data.unitx=x2unit((gint) (x + 0.5));
1096 _gps->data.unity=y2unit((gint) (y + 0.5));
1097 unit2latlon(_gps->data.unitx, _gps->data.unity, _gps->data.lat, _gps->data.lon);
1098 _gps->data.speed=20.f;
1099 gps_data_integerize(&_gps->data);
1100 _gps->data.time=time(NULL);
1101 track_add(&_gps->data);
1106 map_set_place_information(osm_way *s, osm_place *mp, osm_place *sp)
1110 if (!s && !mp && !sp) {
1111 g_snprintf(buffer, sizeof(buffer), _("Unknown location"));
1114 g_snprintf(buffer, sizeof(buffer), "%s%s%s%s%s%s%s%s%s%s",
1115 s ? s->name ? s->name : "" : "",
1116 s ? s->ref ? ", " : "" : "",
1117 s ? s->ref ? s->ref : "" : "",
1118 s ? s->int_ref ? " (" : "" : "",
1119 s ? s->int_ref ? s->int_ref : "" : "",
1120 s ? s->int_ref ? ") " : "" : "",
1121 (sp && sp->name) ? " in " : "",
1122 (sp && sp->name) ? sp->name : "",
1123 (mp && mp->name) ? " in " : "",
1124 (mp && mp->name) ? mp->name : "");
1126 gtk_label_set_label(GTK_LABEL(info_banner.location), buffer);
1130 map_update_destination(gdouble lat, gdouble lon)
1134 static gdouble prev_dt=99999.0;
1135 static gboolean dest_reached=FALSE;
1139 dt=calculate_distance(lat, lon, _dest.lat, _dest.lon);
1140 dh=calculate_course(lat, lon, _dest.lat, _dest.lon);
1141 cdist=dt*UNITS_CONVERT[_units];
1143 g_snprintf(buffer, sizeof(buffer), "%.02f %s (%0.02f)", cdist, UNITS_TEXT[_units], dh<0 ? 360+dh : dh);
1144 gtk_label_set_label(GTK_LABEL(info_banner.distance), buffer);
1146 if (dt<0.005 && dest_reached==FALSE) {
1148 announce_destination_reached();
1150 } else if (dt<prev_dt-KM10KNOTS) {
1152 announce_distance_to_destination(cdist, UNITS_TEXT[_units], KM10KNOTS);
1154 } else if (dt>prev_dt+KM10KNOTS/4) {
1161 g_printf("%f (Prev:%f)\n", prev_dt, dt);
1166 gtk_label_set_label(GTK_LABEL(info_banner.distance), "");
1168 gtk_compass_set_dest_heading(_gps_compass, _dest.valid, (gfloat)dh);
1169 gtk_compass_set_dest_heading(_tab_compass, _dest.valid, (gfloat)dh);
1171 if (_next_way && _next_way->point) {
1172 gdouble wp_lat, wp_lon;
1175 unit2latlon(_next_way->point->unitx,_next_way->point->unity, wp_lat, wp_lon);
1176 wc=calculate_course(lat, lon, wp_lat, wp_lon);
1177 gtk_compass_set_way_heading(_gps_compass, TRUE, wc);
1178 gtk_compass_set_way_heading(_tab_compass, TRUE, wc);
1180 gtk_compass_set_way_heading(_gps_compass, FALSE, 0);
1181 gtk_compass_set_way_heading(_tab_compass, FALSE, 0);
1187 map_update_location(gdouble lat, gdouble lon, gboolean force)
1190 static gboolean inp=FALSE;
1192 /* We run the gtk mainloop in progress callback so we can be called again, we don't like that */
1197 ilat=lat2mp_int(lat);
1198 ilon=lon2mp_int(lon);
1200 if (_gps->data.fix>1 && !force)
1201 osm_set_way_range_from_speed(_gps->data.speed);
1203 osm_set_way_range(OSM_RANGE_WAY/4);
1205 osm_progress_set_widget(_db, _progress_item);
1206 osm_get_location_data(ilat, ilon, _gps->data.heading, &map_loc);
1208 map_set_place_information(map_loc.street, map_loc.primary, map_loc.secondary);
1210 map_set_place_information(NULL, NULL, NULL);
1211 osm_progress_set_widget(_db, NULL);
1213 map_update_destination(lat, lon);
1219 * Mouse scroller zoom in/out callback
1222 map_cb_scroll_event(GtkWidget * widget, GdkEventScroll * event)
1224 if (event->direction == GDK_SCROLL_UP) {
1225 map_center_unit(x2unit((gint) (event->x + 0.5)), y2unit((gint) (event->y + 0.5)));
1226 map_set_zoom(_zoom - 1);
1227 } else if (event->direction == GDK_SCROLL_DOWN) {
1228 map_center_unit(x2unit((gint) (event->x + 0.5)), y2unit((gint) (event->y + 0.5)));
1229 map_set_zoom(_zoom + 1);
1235 * Start map drag operation
1238 map_drag_start(gint x,gint y)
1242 before[0] = press[0];
1243 before[1] = press[1];
1244 _center_mode=CENTER_MANUAL;
1246 g_signal_handler_disconnect(G_OBJECT(_map_widget), map_drag_id);
1248 map_drag_id=g_signal_connect(G_OBJECT(_map_widget), "motion_notify_event", G_CALLBACK(map_follow_move_cb), NULL);
1252 * Stop map drag operation
1255 map_drag_stop(gint x, gint y)
1260 g_signal_handler_disconnect(G_OBJECT(_map_widget), map_drag_id);
1273 /* Workaround hildon content menu problem */
1275 map_cb_show_poi_info_dialog(gpointer data)
1277 guint poi_id=GPOINTER_TO_INT(data);
1278 if (poi_info_dialog(poi_id)==FALSE)
1279 g_printerr("Huh? Failed to display info dialog\n");
1284 map_cb_button_press(GtkWidget * widget, GdkEventButton * event)
1286 _cmenu_position_x = event->x + 0.5;
1287 _cmenu_position_y = event->y + 0.5;
1289 switch (event->button) {
1291 if (event->type==GDK_2BUTTON_PRESS) {
1292 map_center_unit(x2unit((gint) (event->x + 0.5)), y2unit((gint) (event->y + 0.5)));
1293 #ifdef MAP_ZOOM_ON_DOUBLE_CLICK
1294 map_set_zoom(_zoom-1);
1296 map_data_needs_refresh=TRUE;
1299 if (event->type==GDK_3BUTTON_PRESS) {
1303 map_drag_start(event->x, event->y);
1307 map_set_zoom(_zoom - 1);
1311 gtk_menu_popup(GTK_MENU(_menu_map), NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time());
1315 /* Return FALSE to allow context menu to work. */
1320 map_cb_button_release(GtkWidget *widget, GdkEventButton *event)
1326 switch (event->button) {
1329 set_action_activate("autocenter_none", TRUE);
1332 case MAP_MODE_DRAW_TRACK:
1333 map_draw_track(event->x, event->y);
1335 case MAP_MODE_DRAW_ROUTE:
1336 map_draw_route(event->x, event->y);
1338 case MAP_MODE_SET_ROUTE_FROM:
1339 case MAP_MODE_SET_ROUTE_POINT:
1340 case MAP_MODE_SET_ROUTE_TO:
1343 ux=x2unit(_cmenu_position_x);
1344 uy=y2unit(_cmenu_position_y);
1346 unit2latlon(ux, uy, lat, lon);
1347 if (map_poi_find_at_latlon(lat, lon, &poi_id)==TRUE) {
1348 g_printf("POI: %d\n", poi_id);
1349 g_idle_add_full(G_PRIORITY_HIGH_IDLE,(GSourceFunc)map_cb_show_poi_info_dialog, GINT_TO_POINTER(poi_id), NULL);
1351 if (map_data_needs_refresh==TRUE) {
1352 map_data_needs_refresh=FALSE;
1354 g_idle_add_full(G_PRIORITY_HIGH_IDLE,(GSourceFunc)map_update_location_from_center, NULL, NULL);
1356 map_drag_stop(event->x, event->y);
1367 /* Return FALSE to avoid context menu (if it hasn't popped up already). */
1372 map_dialog_goto_latlon(void)
1380 dialog = gtk_dialog_new_with_buttons(_("Go to Lat/Lon"),
1381 GTK_WINDOW(_window),
1382 GTK_DIALOG_MODAL, GTK_STOCK_OK,
1383 GTK_RESPONSE_ACCEPT,
1385 GTK_RESPONSE_REJECT, NULL);
1387 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table = gtk_table_new(2, 3, FALSE), TRUE, TRUE, 0);
1389 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Latitude")),0, 1, 0, 1, GTK_FILL, 0, 2, 4);
1390 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
1392 gtk_table_attach(GTK_TABLE(table), txt_lat = gtk_entry_new(), 1, 2, 0, 1, GTK_FILL, 0, 2, 4);
1393 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
1395 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Longitude")), 0, 1, 1, 2, GTK_FILL, 0, 2, 4);
1396 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
1398 gtk_table_attach(GTK_TABLE(table), txt_lon = gtk_entry_new(), 1, 2, 1, 2, GTK_FILL, 0, 2, 4);
1399 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
1401 #if defined (WITH_DEVICE_770) && !defined(WITH_HILDON_NEW)
1402 g_object_set(G_OBJECT(txt_lat), HILDON_INPUT_MODE_HINT, HILDON_INPUT_MODE_HINT_NUMERICSPECIAL, NULL);
1403 g_object_set(G_OBJECT(txt_lon), HILDON_INPUT_MODE_HINT, HILDON_INPUT_MODE_HINT_NUMERICSPECIAL, NULL);
1406 /* Initialize with the current center position. */
1410 unit2latlon(_center.unitx, _center.unity, lat, lon);
1411 g_snprintf(buffer, sizeof(buffer), "%.06f", lat);
1412 gtk_label_set_text(GTK_LABEL(txt_lat), buffer);
1413 g_snprintf(buffer, sizeof(buffer), "%.06f", lon);
1414 gtk_label_set_text(GTK_LABEL(txt_lon), buffer);
1417 gtk_widget_show_all(dialog);
1419 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
1425 text = gtk_entry_get_text(GTK_ENTRY(txt_lat));
1426 lat = strtof(text, &error_check);
1427 if (text == error_check || lat < -90.f || lat > 90.f) {
1428 popup_error(dialog, _("Invalid Latitude"));
1432 text = gtk_entry_get_text(GTK_ENTRY(txt_lon));
1433 lon = strtof(text, &error_check);
1434 if (text == error_check || lon < -180.f || lon > 180.f) {
1435 popup_error(dialog, _("Invalid Longitude"));
1439 latlon2unit(lat, lon, unitx, unity);
1440 if (_center_mode > 0)
1441 set_action_activate("autocenter_none", TRUE);
1443 map_center_unit(unitx, unity);
1446 gtk_widget_destroy(dialog);