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

   1 /*
   2  * This file is part of mapper
   3  *
   4  * Copyright (C) 2007 Kaj-Michael Lang
   5  * Copyright (C) 2006-2007 John Costigan.
   6  *
   7  * POI and GPS-Info code originally written by Cezary Jackiewicz.
   8  *
   9  * Default map data provided by http://www.openstreetmap.org/
  10  *
  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.
  15  *
  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.
  20  *
  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.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <strings.h>
  32 #include <stddef.h>
  33 #include <locale.h>
  34 #include <errno.h>
  35 #include <sys/wait.h>
  36 #include <glib/gstdio.h>
  37 #include <gtk/gtk.h>
  38 #include <gdk/gdkkeysyms.h>
  39 #include <fcntl.h>
  40 #include <libintl.h>
  41 #include <locale.h>
  42
  43 #include "hildon-mapper.h"
  44
  45 #include "utils.h"
  46 #include "poi.h"
  47 #include "path.h"
  48 #include "settings.h"
  49 #include "gps.h"
  50 #include "mapper-types.h"
  51 #include "ui-common.h"
  52 #include "db.h"
  53 #include "latlon.h"
  54 #include "cb.h"
  55 #include "poi-gui.h"
  56 #include "gps-panels.h"
  57 #include "gps-conn.h"
  58 #include "search.h"
  59 #include "dialogs.h"
  60 #include "filter-gui.h"
  61 #include "help.h"
  62 #include "map-repo.h"
  63 #include "config-gconf.h"
  64 #include "gtkmap.h"
  65
  66 static gboolean
  67 path_tree_view_update_store(GtkWidget *tree_view, Path *path)
  68 {
  69 GtkListStore *store;
  70
  71 g_assert(tree_view);
  72 g_assert(path);
  73
  74 store=path_get_waypoints_store(path);
  75 if (!store)
  76         return FALSE;
  77
  78 gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), store);
  79 g_object_unref(G_OBJECT(store));
  80 return TRUE;
  81 }
  82
  83 /***********************
  84   Route menu callbacks
  85  ***********************/
  86 gboolean
  87 menu_cb_route_download(GtkAction *action)
  88 {
  89 route_download(_route, NULL);
  90 route_menu_set_sensitive(path_tree_view_update_store(route_tree_view, _route));
  91 return TRUE;
  92 }
  93
  94 gboolean
  95 menu_cb_route_open(GtkAction *action)
  96 {
  97 route_open_file(_route);
  98 route_menu_set_sensitive(path_tree_view_update_store(route_tree_view, _route));
  99 return TRUE;
 100 }
 101
 102 gboolean
 103 menu_cb_route_save(GtkAction *action)
 104 {
 105 route_save(_route);
 106 return TRUE;
 107 }
 108
 109 gboolean
 110 menu_cb_route_distnext(GtkAction *action)
 111 {
 112 path_show_distance_to_next(_route);
 113 return TRUE;
 114 }
 115
 116 gboolean
 117 menu_cb_route_distlast(GtkAction *action)
 118 {
 119 path_show_distance_to_last(_route);
 120 return TRUE;
 121 }
 122
 123 gboolean
 124 menu_cb_route_reset(GtkAction *action)
 125 {
 126 path_find_nearest_point(_route);
 127 gtk_map_refresh(_map);
 128 return TRUE;
 129 }
 130
 131 gboolean
 132 menu_cb_route_clear(GtkAction *action)
 133 {
 134 if (route_clear(_route)) {
 135         gtk_tree_view_set_model(route_tree_view, NULL);
 136         route_menu_set_sensitive(FALSE);
 137 }
 138 return TRUE;
 139 }
 140
 141 /***********************
 142   Track menu callbacks
 143  ***********************/
 144 gboolean
 145 menu_cb_track_open(GtkAction *action)
 146 {
 147 track_open(_track);
 148 path_tree_view_update_store(track_tree_view, _track);
 149 return TRUE;
 150 }
 151
 152 gboolean
 153 menu_cb_track_save(GtkAction *action)
 154 {
 155 track_save(_track);
 156 path_tree_view_update_store(track_tree_view, _track);
 157 return TRUE;
 158 }
 159
 160 gboolean
 161 menu_cb_track_insert_break(GtkAction *action)
 162 {
 163 path_insert_break(_track);
 164 path_tree_view_update_store(track_tree_view, _track);
 165 return TRUE;
 166 }
 167
 168 gboolean
 169 menu_cb_track_insert_mark(GtkAction *action)
 170 {
 171 if (path_insert_mark(_track)) {
 172         path_tree_view_update_store(track_tree_view, _track);
 173 }
 174 return TRUE;
 175 }
 176
 177 gboolean
 178 menu_cb_track_distlast(GtkAction *action)
 179 {
 180 path_show_distance_from_last(_track);
 181 return TRUE;
 182 }
 183
 184 gboolean
 185 menu_cb_track_distfirst(GtkAction *action)
 186 {
 187 path_show_distance_from_first(_track);
 188 return TRUE;
 189 }
 190
 191 gboolean
 192 menu_cb_track_clear(GtkAction *action)
 193 {
 194 path_clear(_track);
 195 path_tree_view_update_store(track_tree_view, _track);
 196 return TRUE;
 197 }
 198
 199 gboolean
 200 menu_cb_track_filter(GtkAction *action)
 201 {
 202 filter_dialog(_window);
 203 return TRUE;
 204 }
 205
 206 /***********************
 207   Other menu callbacks
 208  ***********************/
 209 gboolean
 210 menu_cb_show_tracks(GtkAction *action)
 211 {
 212 _show_tracks ^= TRACKS_MASK;
 213 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action))) {
 214         _show_tracks |= TRACKS_MASK;
 215         gtk_map_set_path_display(_map, _show_tracks);
 216         MACRO_BANNER_SHOW_INFO(_window, _("Tracks are now shown"));
 217 } else {
 218         _show_tracks &= ~TRACKS_MASK;
 219         gtk_map_set_path_display(_map, _show_tracks);
 220         MACRO_BANNER_SHOW_INFO(_window, _("Tracks are now hidden"));
 221 }
 222 return TRUE;
 223 }
 224
 225 gboolean
 226 menu_cb_show_scale(GtkAction *action)
 227 {
 228 _show_scale = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
 229 /* XXXXXXXXXXXXXXXXX */
 230 return TRUE;
 231 }
 232
 233 gboolean
 234 menu_cb_show_routes(GtkAction *action)
 235 {
 236 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action))) {
 237         _show_tracks |= ROUTES_MASK;
 238         gtk_map_set_path_display(_map, _show_tracks);
 239         MACRO_BANNER_SHOW_INFO(_window, _("Routes are now shown"));
 240 } else {
 241         _show_tracks &= ~ROUTES_MASK;
 242         gtk_map_set_path_display(_map, _show_tracks);
 243         MACRO_BANNER_SHOW_INFO(_window, _("Routes are now hidden"));
 244 }
 245 return TRUE;
 246 }
 247
 248 gboolean
 249 menu_cb_show_velvec(GtkAction *action)
 250 {
 251 _show_velvec = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
 252 g_object_set(_map, "show-velvec", _show_velvec, NULL);
 253 return TRUE;
 254 }
 255
 256 gboolean
 257 menu_cb_show_poi(GtkAction *action)
 258 {
 259 _show_poi = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
 260 g_object_set(_map, "show-markers", _show_poi, NULL);
 261 return TRUE;
 262 }
 263
 264 gboolean
 265 menu_cb_gps_show_info(GtkAction *action)
 266 {
 267 _gps_info = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
 268 gps_show_info(_gps);
 269 return TRUE;
 270 }
 271
 272 gboolean
 273 menu_cb_autocenter(GtkAction *action, GtkRadioAction *current)
 274 {
 275 gint value=gtk_radio_action_get_current_value(GTK_RADIO_ACTION(current));
 276
 277 switch (value) {
 278         case CENTER_LEAD:
 279                 gtk_map_set_center_mode(_map, CENTER_LEAD);
 280                 MACRO_BANNER_SHOW_INFO(_window, _("Auto-Center Mode: Lead"));
 281         break;
 282         case CENTER_LATLON:
 283                 gtk_map_set_center_mode(_map, CENTER_LATLON);
 284                 MACRO_BANNER_SHOW_INFO(_window, _("Auto-Center Mode: Lat/Lon"));
 285         break;
 286         case CENTER_MANUAL:
 287         default:
 288                 gtk_map_set_center_mode(_map, CENTER_MANUAL);
 289                 MACRO_BANNER_SHOW_INFO(_window, _("Auto-Center Off"));
 290         break;
 291 }
 292
 293 return TRUE;
 294 }
 295
 296 gboolean
 297 menu_cb_goto_latlon(GtkAction *action)
 298 {
 299 gtk_map_dialog_goto_latlon();
 300 return TRUE;
 301 }
 302
 303 gboolean
 304 menu_cb_goto_home(GtkAction *action)
 305 {
 306 if (gtk_map_goto_position(_home)==FALSE) {
 307         MACRO_BANNER_SHOW_INFO(_window, _("Home not set."));
 308 } else {
 309         if (gtk_map_get_zoom(_map)>3)
 310                 gtk_map_set_zoom(_map, 3);
 311         MACRO_BANNER_SHOW_INFO(_window, _("At home location"));
 312 }
 313 return TRUE;
 314 }
 315
 316 gboolean
 317 menu_cb_goto_destination(GtkAction *action)
 318 {
 319 if (gtk_map_goto_position(_dest)==FALSE) {
 320         MACRO_BANNER_SHOW_INFO(_window, _("Destination has not been set."));
 321 } else {
 322         if (gtk_map_get_zoom(_map)>3)
 323                 gtk_map_set_zoom(_map, 3);
 324         MACRO_BANNER_SHOW_INFO(_window, _("At destination point"));
 325 }
 326 return TRUE;
 327 }
 328
 329 gboolean
 330 menu_cb_goto_gps(GtkAction *action)
 331 {
 332 if (gtk_map_set_center_mode(_map, CENTER_LATLON)) {
 333         MACRO_BANNER_SHOW_INFO(_window, _("At GPS track coordinates."));
 334 } else {
 335         MACRO_BANNER_SHOW_INFO(_window, _("No active GPS track."));
 336 }
 337 return TRUE;
 338 }
 339
 340 gboolean
 341 menu_cb_goto_nextway(GtkAction *action)
 342 {
 343 GtkMapCenterMode cm;
 344
 345 g_return_val_if_fail(_route, TRUE);
 346
 347 if (_route->next_way && _route->next_way->point && _route->next_way->point->unity && _route->next_way->point->unitx) {
 348         g_object_get(_map, "center-mode", &cm);
 349         if (cm>0)
 350                 set_action_activate("autocenter_none", TRUE);
 351
 352         gtk_map_set_center(_map, _route->next_way->point->unitx, _route->next_way->point->unity);
 353         if (gtk_map_get_zoom(_map)>3)
 354                 gtk_map_set_zoom(_map, 3);
 355 } else {
 356         MACRO_BANNER_SHOW_INFO(_window, _("There is no next waypoint."));
 357 }
 358
 359 return TRUE;
 360 }
 361
 362 gboolean
 363 menu_cb_goto_nearpoi(GtkAction *action)
 364 {
 365 GtkMapCenterMode cm;
 366 gdouble lat, lon;
 367 poi_info *p;
 368
 369 gtk_map_get_center_latlon(_map, &lat, &lon);
 370
 371 p=poi_find_nearest(lat, lon);
 372 if (p) {
 373         gchar *banner;
 374
 375         banner = g_strdup_printf("%s (%s)", p->label, p->cat_label);
 376         MACRO_BANNER_SHOW_INFO(_window, banner);
 377         g_free(banner);
 378         poi_free(p);
 379
 380         g_object_get(_map, "center-mode", &cm);
 381         if (cm!=CENTER_MANUAL)
 382                 set_action_activate("autocenter_none", TRUE);
 383
 384         gtk_map_set_center_latlon(_map, p->lat, p->lon);
 385 } else {
 386         MACRO_BANNER_SHOW_INFO(_window, _("No POIs found."));
 387 }
 388
 389 return TRUE;
 390 }
 391
 392 gboolean
 393 menu_cb_maps_repoman(GtkAction *action)
 394 {
 395 repoman_dialog();
 396 return TRUE;
 397 }
 398
 399 gboolean
 400 menu_cb_maps_select(GtkAction *action, gpointer new_repo)
 401 {
 402 gtk_map_set_repo(_map, new_repo);
 403 return TRUE;
 404 }
 405
 406 gboolean
 407 cb_zoom_auto(GtkAction *action)
 408 {
 409 gtk_map_set_autozoom(_map, TRUE);
 410 return TRUE;
 411 }
 412
 413 gboolean
 414 cb_zoom_base(GtkAction *action)
 415 {
 416 gtk_map_set_autozoom(_map, FALSE);
 417 return TRUE;
 418 }
 419
 420 gboolean
 421 cb_zoomin(GtkAction *action)
 422 {
 423 g_idle_add((GSourceFunc)gtk_map_zoom_in, NULL);
 424 return TRUE;
 425 }
 426
 427 gboolean
 428 cb_zoomout(GtkAction *action)
 429 {
 430 g_idle_add((GSourceFunc)gtk_map_zoom_out, NULL);
 431 return TRUE;
 432 }
 433
 434 gboolean
 435 cb_fullscreen(GtkAction *action)
 436 {
 437 if ((_fullscreen = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action)))) {
 438         gtk_window_fullscreen(GTK_WINDOW(_window));
 439 } else {
 440         gtk_window_unfullscreen(GTK_WINDOW(_window));
 441 }
 442 gtk_idle_add((GSourceFunc) window_present, NULL);
 443 return TRUE;
 444 }
 445
 446 gboolean
 447 menu_cb_view_toolbar(GtkAction *action)
 448 {
 449 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action)))
 450         gtk_widget_show(_toolbar);
 451 else
 452         gtk_widget_hide(_toolbar);
 453
 454 return TRUE;
 455 }
 456
 457 gboolean
 458 menu_cb_enable_gps(GtkAction *action)
 459 {
 460 if ((_enable_gps = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action)))) {
 461         if (_gps->io.address) {
 462                 gps_conn_set_state(_gps, RCVR_DOWN);
 463                 gps_connect_now(_gps);
 464         } else {
 465                 MACRO_BANNER_SHOW_INFO(_window, _("Cannot enable GPS until a GPS Receiver has been configured in the GPS Settings dialog."));
 466                 set_action_activate("gps_enabled", FALSE);
 467         }
 468 } else {
 469         if (_gps->io.conn > RCVR_OFF)
 470                 gps_conn_set_state(_gps, RCVR_OFF);
 471         gps_disconnect(_gps);
 472         path_add_break(_track);
 473         _speed_excess=FALSE;
 474 }
 475 if (_enable_gps==FALSE)
 476         set_action_activate("autocenter_none", TRUE);
 477 set_action_sensitive("goto_gps", _enable_gps);
 478 set_action_sensitive("autocenter_latlon", _enable_gps);
 479 set_action_sensitive("autocenter_lead", _enable_gps);
 480
 481 gps_show_info(&_gps->data);
 482
 483 return TRUE;
 484 }
 485
 486 gboolean
 487 menu_cb_auto_download(GtkAction *action)
 488 {
 489 if ((_auto_download = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action)) )) {
 490         if (_curr_repo->url == REPOTYPE_NONE)
 491                 popup_error(_window, _("NOTE: You must set a Map URI in the current repository in order to download maps."));
 492         gtk_map_refresh(_map);
 493 } else {
 494         map_download_stop();
 495 }
 496
 497 return TRUE;
 498 }
 499
 500 gboolean
 501 menu_cb_settings(GtkAction *action)
 502 {
 503 if (settings_dialog()) {
 504         gtk_map_refresh(_map);
 505 }
 506 return TRUE;
 507 }
 508
 509 gboolean
 510 menu_cb_settings_gps(GtkAction *action)
 511 {
 512 if (settings_dialog_gps(_gps)) {
 513         /* Settings have changed - reconnect to receiver. */
 514         if (_enable_gps) {
 515                 gps_conn_set_state(_gps, RCVR_DOWN);
 516                 gps_disconnect(_gps);
 517                 gps_connect_now(_gps);
 518         }
 519 }
 520
 521 return TRUE;
 522 }
 523
 524 gboolean
 525 menu_cb_settings_colors(GtkAction *action)
 526 {
 527 settings_dialog_colors();
 528 return TRUE;
 529 }
 530
 531 gboolean
 532 menu_cb_settings_osm(GtkAction *action)
 533 {
 534 settings_dialog_osm();
 535 return TRUE;
 536 }
 537
 538 gboolean
 539 menu_cb_settings_keys(GtkAction *action)
 540 {
 541 settings_dialog_hardkeys();
 542 return TRUE;
 543 }
 544
 545 gboolean
 546 menu_cb_import_osm(GtkAction *action)
 547 {
 548 osm_import_dialog(_window);
 549 return TRUE;
 550 }
 551
 552 gboolean
 553 menu_cb_help(GtkAction *action)
 554 {
 555 help_topic_display(HELP_ID_INTRO, 0);
 556 return TRUE;
 557 }
 558
 559 gboolean
 560 menu_cb_about(GtkAction *action)
 561 {
 562 gchar *authors[]={
 563         "Kaj-Michael Lang",
 564         "John Costigan",
 565         "Cezary Jackiewicz", NULL
 566 };
 567
 568 gtk_show_about_dialog(GTK_WINDOW(_window),
 569         "name", "Mapper",
 570         "version", VERSION,
 571         "copyright", "Kaj-Michael Lang",
 572         "license", "GPL",
 573         "authors", authors,
 574         NULL);
 575 return TRUE;
 576 }
 577
 578 static CustomKey
 579 custom_key_get_type(gint keyval)
 580 {
 581 switch (keyval) {
 582         case HILDON_HARDKEY_UP:
 583                 return CUSTOM_KEY_UP;
 584         break;
 585         case HILDON_HARDKEY_DOWN:
 586                 return CUSTOM_KEY_DOWN;
 587         break;
 588         case HILDON_HARDKEY_LEFT:
 589                 return CUSTOM_KEY_LEFT;
 590         break;
 591         case HILDON_HARDKEY_RIGHT:
 592                 return CUSTOM_KEY_RIGHT;
 593         break;
 594         case HILDON_HARDKEY_SELECT:
 595                 return CUSTOM_KEY_SELECT;
 596         break;
 597         case HILDON_HARDKEY_INCREASE:
 598                 return CUSTOM_KEY_INCREASE;
 599         break;
 600         case HILDON_HARDKEY_DECREASE:
 601                 return CUSTOM_KEY_DECREASE;
 602         break;
 603         case HILDON_HARDKEY_FULLSCREEN:
 604                 return CUSTOM_KEY_FULLSCREEN;
 605         break;
 606         case HILDON_HARDKEY_ESC:
 607                 return CUSTOM_KEY_ESC;
 608         break;
 609         default:
 610                 return CUSTOM_KEY_ENUM_COUNT;
 611 }
 612
 613 }
 614
 615 gboolean
 616 window_cb_key_press(GtkWidget * widget, GdkEventKey * event)
 617 {
 618 CustomKey custom_key;
 619 GtkMapCenterMode cm;
 620
 621 custom_key=custom_key_get_type(event->keyval);
 622 if (custom_key==CUSTOM_KEY_ENUM_COUNT)
 623         return FALSE;
 624
 625 switch (_action[custom_key]) {
 626         case CUSTOM_ACTION_PAN_NORTH:
 627                 gtk_map_pan(_map, 0, -1);
 628         break;
 629         case CUSTOM_ACTION_PAN_WEST:
 630                 gtk_map_pan(_map, -1, 0);
 631         break;
 632         case CUSTOM_ACTION_PAN_SOUTH:
 633                 gtk_map_pan(_map, 0, 1);
 634         break;
 635         case CUSTOM_ACTION_PAN_EAST:
 636                 gtk_map_pan(_map, 1, 0);
 637         break;
 638         case CUSTOM_ACTION_TOGGLE_AUTOCENTER:
 639                 g_object_get(_map, "center-mode", &cm);
 640                 switch (cm) {
 641                         case CENTER_LATLON:
 642                         case CENTER_WAS_LEAD:
 643                                 set_action_activate("autocenter_lead", TRUE);
 644                         break;
 645                         case CENTER_LEAD:
 646                         case CENTER_WAS_LATLON:
 647                                 set_action_activate("autocenter_latlon", TRUE);
 648                         break;
 649                         default:
 650                                 set_action_activate("autocenter_latlon", TRUE);
 651                         break;
 652                 }
 653         break;
 654         case CUSTOM_ACTION_ZOOM_IN:
 655                 gtk_map_zoom_in(_map);
 656         break;
 657         case CUSTOM_ACTION_ZOOM_OUT:
 658                 gtk_map_zoom_out(_map);
 659         break;
 660         case CUSTOM_ACTION_TOGGLE_FULLSCREEN:
 661                 set_action_activate("view_fullscreen", !_fullscreen);
 662         break;
 663         case CUSTOM_ACTION_TOGGLE_TRACKS:
 664                 switch (_show_tracks) {
 665                 case 0:
 666                         /* Nothing shown, nothing saved; just set both. */
 667                         _show_tracks = TRACKS_MASK | ROUTES_MASK;
 668                         break;
 669                 case TRACKS_MASK << 16:
 670                 case ROUTES_MASK << 16:
 671                 case (ROUTES_MASK | TRACKS_MASK) << 16:
 672                         /* Something was saved and nothing changed since.
 673                          * Restore saved. */
 674                         _show_tracks = _show_tracks >> 16;
 675                         break;
 676                 default:
 677                         /* There is no history, or they changed something
 678                          * since the last historical change. Save and
 679                          * clear. */
 680                         _show_tracks = _show_tracks << 16;
 681                 }
 682                 set_action_activate("view_route", _show_tracks & ROUTES_MASK);
 683                 set_action_activate("view_track", _show_tracks & TRACKS_MASK);
 684         break;
 685         case CUSTOM_ACTION_TOGGLE_SCALE:
 686                 set_action_activate("view_scale", _show_scale);
 687         break;
 688         case CUSTOM_ACTION_TOGGLE_POI:
 689                 set_action_activate("view_poi", _show_poi);
 690         break;
 691         case CUSTOM_ACTION_CHANGE_REPO: {
 692                         GList *curr = g_list_find(_repo_list, _curr_repo);
 693                         if (!curr)
 694                                 break;
 695
 696                         /* Loop until we reach a next-able repo, or until we get
 697                          * back to the current repo. */
 698                         while ((curr = (curr->next ? curr->next : _repo_list)) && !((RepoData *) curr->data)->nextable && curr->data != _curr_repo) {
 699                         }
 700
 701                         if (curr->data != _curr_repo) {
 702                                 repo_set_curr(curr->data);
 703                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_curr_repo->menu_item), TRUE);
 704                         } else {
 705                                 popup_error(_window, _("There are no other next-able repositories."));
 706                         }
 707                         break;
 708                 }
 709         break;
 710         case CUSTOM_ACTION_ROUTE_DISTNEXT:
 711                 path_show_distance_to_next(_route);
 712         break;
 713         case CUSTOM_ACTION_ROUTE_DISTLAST:
 714                 path_show_distance_to_last(_route);
 715         break;
 716         case CUSTOM_ACTION_TRACK_BREAK:
 717                 path_add_break(_track);
 718         break;
 719         case CUSTOM_ACTION_TRACK_DISTLAST:
 720                 path_show_distance_from_last(_track);
 721         break;
 722         case CUSTOM_ACTION_TRACK_DISTFIRST:
 723                 path_show_distance_from_first(_track);
 724         break;
 725         case CUSTOM_ACTION_TOGGLE_GPS:
 726                 set_action_activate("gps_enable", !_enable_gps);
 727         break;
 728         case CUSTOM_ACTION_TOGGLE_GPSINFO:
 729                 set_action_activate("gps_info", !_gps_info);
 730         break;
 731         case CUSTOM_ACTION_TOGGLE_SPEEDLIMIT:
 732                 _speed_on ^= 1;
 733         break;
 734         default:
 735                 return FALSE;
 736 }
 737 return TRUE;
 738 }
 739
 740 gboolean
 741 window_cb_key_release(GtkWidget * widget, GdkEventKey * event)
 742 {
 743 switch (event->keyval) {
 744         case HILDON_HARDKEY_INCREASE:
 745                 gtk_map_zoom_in(_map);
 746         break;
 747         case HILDON_HARDKEY_DECREASE:
 748                 gtk_map_zoom_out(_map);
 749         break;
 750         default:
 751         break;
 752 }
 753 return FALSE;
 754 }
 755
 756 void
 757 cmenu_show_latlon(gdouble lat, gdouble lon)
 758 {
 759 gchar buffer[80], tmp1[16], tmp2[16];
 760
 761 lat_format(_degformat, lat, tmp1);
 762 lon_format(_degformat, lon, tmp2);
 763
 764 g_snprintf(buffer, sizeof(buffer), "%s: %s\n%s: %s", _("Latitude"), tmp1, _("Longitude"), tmp2);
 765 /* XXX: Use a dialog under plain Gtk */
 766 MACRO_BANNER_SHOW_INFO(_window, buffer);
 767 }
 768
 769 void
 770 cmenu_clip_latlon(gdouble lat, gdouble lon)
 771 {
 772 gchar buffer[80];
 773
 774 g_snprintf(buffer, sizeof(buffer), "%.06f,%.06f", lat, lon);
 775
 776 gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), buffer, -1);
 777 }
 778
 779 void
 780 cmenu_route_to(gdouble lat, gdouble lon)
 781 {
 782 gchar buffer[80];
 783 gchar strlat[32];
 784 gchar strlon[32];
 785
 786 g_ascii_formatd(strlat, 32, "%.06f", lat);
 787 g_ascii_formatd(strlon, 32, "%.06f", lon);
 788 g_snprintf(buffer, sizeof(buffer), "%s, %s", strlat, strlon);
 789
 790 route_download(_route, buffer);
 791 }
 792
 793 void
 794 cmenu_distance_to(gdouble lat, gdouble lon)
 795 {
 796 gchar buffer[80];
 797
 798 g_snprintf(buffer, sizeof(buffer), "%s: %.02lf %s", _("Distance"),
 799          calculate_distance(_gps->data.lat, _gps->data.lon, lat, lon) * UNITS_CONVERT[_units], UNITS_TEXT[_units]);
 800 MACRO_BANNER_SHOW_INFO(_window, buffer);
 801 }
 802
 803 void
 804 cmenu_route_add_way(gdouble lat, gdouble lon)
 805 {
 806 gchar tmp1[16], tmp2[16], *p_latlon;
 807 GtkWidget *dialog;
 808 GtkWidget *table;
 809 GtkWidget *label;
 810 GtkWidget *txt_scroll;
 811 GtkWidget *txt_desc;
 812
 813 dialog = gtk_dialog_new_with_buttons(_("Add Waypoint"),
 814                              GTK_WINDOW(_window),
 815                              GTK_DIALOG_MODAL, GTK_STOCK_OK,
 816                              GTK_RESPONSE_ACCEPT,
 817                              GTK_STOCK_CANCEL,
 818                              GTK_RESPONSE_REJECT, NULL);
 819
 820 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table = gtk_table_new(2, 2, FALSE), TRUE, TRUE, 0);
 821
 822 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Lat, Lon")), 0, 1, 0, 1, GTK_FILL, 0, 2, 4);
 823 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 824
 825 lat_format(_degformat, lat, tmp1);
 826 lon_format(_degformat, lon, tmp2);
 827 p_latlon = g_strdup_printf("%s, %s", tmp1, tmp2);
 828 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(p_latlon), 1, 2, 0, 1, GTK_FILL, 0, 2, 4);
 829 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
 830 g_free(p_latlon);
 831
 832 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Description")), 0, 1, 1, 2, GTK_FILL, 0, 2, 4);
 833 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 834
 835 txt_scroll = gtk_scrolled_window_new(NULL, NULL);
 836 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scroll), GTK_SHADOW_IN);
 837 gtk_table_attach(GTK_TABLE(table), txt_scroll, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 838
 839 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 840
 841 txt_desc = gtk_text_view_new();
 842 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt_desc), GTK_WRAP_WORD);
 843
 844 gtk_container_add(GTK_CONTAINER(txt_scroll), txt_desc);
 845 gtk_widget_set_size_request(GTK_WIDGET(txt_scroll), 400, 60);
 846
 847 gtk_widget_show_all(dialog);
 848
 849 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 850         GtkTextBuffer *tbuf;
 851         GtkTextIter ti1, ti2;
 852         gchar *desc;
 853
 854         tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_desc));
 855         gtk_text_buffer_get_iter_at_offset(tbuf, &ti1, 0);
 856         gtk_text_buffer_get_end_iter(tbuf, &ti2);
 857         desc = gtk_text_buffer_get_text(tbuf, &ti1, &ti2, TRUE);
 858
 859         path_add_waypoint(_route, lat, lon, desc);
 860         break;
 861 }
 862 gtk_widget_destroy(dialog);
 863 }
 864
 865 gboolean
 866 cmenu_cb_loc_show_latlon(GtkAction *action)
 867 {
 868 gdouble lat, lon;
 869
 870 gtk_map_get_menu_latlon(_map, &lat, &lon);
 871 cmenu_show_latlon(lat, lon);
 872 return TRUE;
 873 }
 874
 875 gboolean
 876 cmenu_cb_loc_clip_latlon(GtkAction *action)
 877 {
 878 gdouble lat, lon;
 879
 880 gtk_map_get_menu_latlon(_map, &lat, &lon);
 881 cmenu_clip_latlon(lat, lon);
 882 return TRUE;
 883 }
 884
 885 gboolean
 886 cmenu_cb_loc_route_to(GtkAction *action)
 887 {
 888 gdouble lat, lon;
 889
 890 gtk_map_get_menu_latlon(_map, &lat, &lon);
 891 cmenu_route_to(lat, lon);
 892 return TRUE;
 893 }
 894
 895 gboolean
 896 cmenu_cb_loc_distance_to(GtkAction *action)
 897 {
 898 gdouble lat, lon;
 899
 900 gtk_map_get_menu_latlon(_map, &lat, &lon);
 901 cmenu_distance_to(lat, lon);
 902 return TRUE;
 903 }
 904
 905 gboolean
 906 cmenu_cb_loc_add_route(GtkAction *action)
 907 {
 908 gdouble lat, lon;
 909
 910 gtk_map_get_menu_latlon(_map, &lat, &lon);
 911 path_add_latlon(_route, lat, lon, time(NULL), 0, 0);
 912 return TRUE;
 913 }
 914
 915 gboolean
 916 cmenu_cb_loc_add_way(GtkAction *action)
 917 {
 918 gdouble lat, lon;
 919
 920 gtk_map_get_menu_latlon(_map, &lat, &lon);
 921 cmenu_route_add_way(lat, lon);
 922 return TRUE;
 923 }
 924
 925 gboolean
 926 cmenu_cb_loc_add_poi(GtkAction *action)
 927 {
 928 poi_info *poi;
 929
 930 poi=poi_new();
 931 gtk_map_get_menu_latlon(_map, &poi->lat, &poi->lon);
 932 poi_edit_dialog(ACTION_ADD_POI, poi);
 933
 934 return TRUE;
 935 }
 936
 937 gboolean
 938 cb_poi_search(GtkAction *action)
 939 {
 940 poi_info poi;
 941 gdouble lat, lon;
 942 GtkMapCenterMode cm;
 943
 944 g_object_get(_map, "center-mode", &cm);
 945 if (cm!=CENTER_MANUAL) {
 946         lat=_gps->data.lat;
 947         lon=_gps->data.lon;
 948 } else {
 949         gtk_map_get_center_latlon(_map, &lat, &lon);
 950 }
 951
 952 mapper_search_dialog(SEARCH_TYPE_POI, lat, lon);
 953 return TRUE;
 954 }
 955
 956 gboolean
 957 cb_poi_add(GtkAction *action)
 958 {
 959 gdouble lat,lon;
 960 const gchar *name = gtk_action_get_name(action);
 961 poi_info *p;
 962
 963 if (gtk_map_get_center_mode(_map)!=CENTER_MANUAL) {
 964         lat=_gps->data.lat;
 965         lon=_gps->data.lon;
 966 } else {
 967         gtk_map_get_center_latlon(_map, &lat, &lon);
 968 }
 969
 970 if (strcmp(name, "poi_add")==0) {
 971         p=poi_new();
 972         p->lat=lat;
 973         p->lon=lon;
 974         poi_edit_dialog(ACTION_ADD_POI, p);
 975         map_poi_cache_clear();
 976 } else if (strcmp(name, "poi_quick_add")==0) {
 977         poi_quick_dialog(lat, lon);
 978         map_poi_cache_clear();
 979 } else
 980         g_assert_not_reached();
 981
 982 return TRUE;
 983 }
 984
 985 gboolean
 986 menu_cb_search_address(GtkAction *action)
 987 {
 988 gdouble lat, lon;
 989
 990 if (gtk_map_get_center_mode(_map)!=CENTER_MANUAL) {
 991         lat=_gps->data.lat;
 992         lon=_gps->data.lon;
 993 } else {
 994         gtk_map_get_center_latlon(_map, &lat, &lon);
 995 }
 996 mapper_search_dialog(SEARCH_TYPE_WAY, lat, lon);
 997 return TRUE;
 998 }
 999
1000 gboolean
1001 cmenu_cb_loc_set_home(GtkAction *action)
1002 {
1003 gtk_map_get_menu_latlon(_map, &_home->lat, &_home->lon);
1004 _home->valid=TRUE;
1005
1006 if (!config_save_position(_home, GCONF_KEY_POSITION_HOME))
1007         popup_error(_window, _("Failed to save home position."));
1008
1009 gtk_map_refresh(_map);
1010 return TRUE;
1011 }
1012
1013 gboolean
1014 cmenu_cb_loc_set_destination(GtkAction *action)
1015 {
1016 gtk_map_get_menu_latlon(_map, &_dest->lat, &_dest->lon);
1017 _dest->valid=TRUE;
1018
1019 if (!config_save_position(&_dest, GCONF_KEY_POSITION_DEST))
1020         popup_error(_window, _("Failed to save destination."));
1021
1022 gtk_map_refresh(_map);
1023 return TRUE;
1024 }
1025
1026 gboolean
1027 cmenu_cb_loc_set_gps(GtkAction *action)
1028 {
1029 gtk_map_get_menu_latlon(_map, &_gps->data.lat, &_gps->data.lon);
1030 _gps->data.time=time(NULL);
1031 path_add_point(_track, &_gps->data);
1032
1033 return TRUE;
1034 }
1035
1036 gboolean
1037 cmenu_cb_way_show_latlon(GtkAction *action)
1038 {
1039 WayPoint *way;
1040 gdouble lat, lon;
1041
1042 gtk_map_get_menu_latlon(_map, &lat, &lon);
1043
1044 if ((way = path_find_nearest_waypoint(_route, lat, lon)))
1045                 cmenu_show_latlon(lat, lon);
1046
1047 return TRUE;
1048 }
1049
1050 gboolean
1051 cmenu_cb_way_show_desc(GtkAction *action)
1052 {
1053 WayPoint *way;
1054 gdouble lat, lon;
1055
1056 gtk_map_get_menu_latlon(_map, &lat, &lon);
1057
1058 if ((way = path_find_nearest_waypoint(_route, lat, lon)))
1059         MACRO_BANNER_SHOW_INFO(_window, way->desc);
1060
1061 return TRUE;
1062 }
1063
1064 gboolean
1065 cmenu_cb_way_clip_latlon(GtkAction *action)
1066 {
1067 WayPoint *way;
1068 gdouble lat, lon;
1069
1070 gtk_map_get_menu_latlon(_map, &lat, &lon);
1071 if ((way = path_find_nearest_waypoint(_route, lat, lon)))
1072                 cmenu_clip_latlon(way->point->unitx, way->point->unity);
1073
1074 return TRUE;
1075 }
1076
1077 gboolean
1078 cmenu_cb_way_clip_desc(GtkAction *action)
1079 {
1080 WayPoint *way;
1081 gdouble lat, lon;
1082
1083 gtk_map_get_menu_latlon(_map, &lat, &lon);
1084 if ((way = path_find_nearest_waypoint(_route, lat, lon)))
1085         gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), way->desc, -1);
1086
1087 return TRUE;
1088 }
1089
1090 gboolean
1091 cmenu_cb_way_route_to(GtkAction *action)
1092 {
1093 WayPoint *way;
1094 gdouble lat, lon;
1095
1096 gtk_map_get_menu_latlon(_map, &lat, &lon);
1097
1098 if ((way = path_find_nearest_waypoint(_route, lat, lon)))
1099         cmenu_route_to(way->point->unitx, way->point->unity);
1100
1101 return TRUE;
1102 }
1103
1104 gboolean
1105 cmenu_cb_way_distance_to(GtkAction *action)
1106 {
1107 WayPoint *way;
1108 gdouble lat, lon;
1109
1110 gtk_map_get_menu_latlon(_map, &lat, &lon);
1111
1112 if ((way = route_find_nearest_waypoint(_route, lat, lon)))
1113         route_show_distance_to(_route, way->point);
1114
1115 return TRUE;
1116 }
1117
1118 gboolean
1119 cmenu_cb_way_delete(GtkAction *action)
1120 {
1121 WayPoint *way;
1122 gdouble lat, lon;
1123
1124 gtk_map_get_menu_latlon(_map, &lat, &lon);
1125
1126 if ((way = path_find_nearest_waypoint(_route, lat, lon))) {
1127         gchar buffer[BUFFER_SIZE];
1128         GtkWidget *confirm;
1129
1130         g_snprintf(buffer, sizeof(buffer), "%s:\n%s\n", _("Confirm delete of waypoint"), way->desc);
1131         confirm = hildon_note_new_confirmation(GTK_WINDOW(_window), buffer);
1132
1133         if (GTK_RESPONSE_OK == gtk_dialog_run(GTK_DIALOG(confirm))) {
1134                 Point *pdel_min, *pdel_max, *pdel_start, *pdel_end;
1135                 guint num_del;
1136
1137                 /* Delete surrounding route data, too. */
1138                 if (way == _route->whead)
1139                         pdel_min = _route->head;
1140                 else
1141                         pdel_min = way[-1].point;
1142
1143                 if (way == _route->wtail)
1144                         pdel_max = _route->tail;
1145                 else
1146                         pdel_max = way[1].point;
1147
1148                 /* Find largest continuous segment around the waypoint, EXCLUDING pdel_min and pdel_max. */
1149                 for (pdel_start = way->point - 1; pdel_start->unity && pdel_start > pdel_min; pdel_start--) {
1150                 }
1151                 for (pdel_end = way->point + 1; pdel_end->unity && pdel_end < pdel_max; pdel_end++) {
1152                 }
1153
1154                 /* If pdel_end is set to _route->tail, and if _route->tail is a non-zero point, then delete _route->tail. */
1155                 if (pdel_end == _route->tail && pdel_end->unity)
1156                         pdel_end++;     /* delete _route->tail too */
1157                 /* else, if *both* endpoints are zero points, delete one. */
1158                 else if (!pdel_start->unity && !pdel_end->unity)
1159                         pdel_start--;
1160
1161                 /* Delete BETWEEN pdel_start and pdel_end, exclusive. */
1162                 num_del = pdel_end - pdel_start - 1;
1163
1164                 memmove(pdel_start + 1, pdel_end,(_route->tail - pdel_end + 1) * sizeof(Point));
1165                 _route->tail -= num_del;
1166
1167                 /* Remove waypoint and move/adjust subsequent waypoints. */
1168                 g_free(way->desc);
1169                 while (way++ != _route->wtail) {
1170                         way[-1] = *way;
1171                         way[-1].point -= num_del;
1172                 }
1173                 _route->wtail--;
1174
1175                 path_find_nearest_point(_route);
1176         }
1177         gtk_widget_destroy(confirm);
1178 }
1179
1180 return TRUE;
1181 }
1182
1183 gboolean
1184 menu_cb_category(GtkAction *action)
1185 {
1186 if (poi_category_list())
1187         gtk_map_refresh(_map);
1188
1189 return TRUE;
1190 }
1191
1192 gboolean
1193 cmenu_cb_way_add_poi(GtkAction *action)
1194 {
1195 WayPoint *way;
1196 gdouble lat, lon;
1197
1198 gtk_map_get_menu_latlon(_map, &lat, &lon);
1199
1200 if ((way = path_find_nearest_waypoint(_route, lat, lon))) {
1201         poi_info *p;
1202
1203         p=poi_new();
1204         path_get_waypoint_latlon(way, &p->lat, &p->lon);
1205         poi_edit_dialog(ACTION_ADD_POI, p);
1206 }
1207 return TRUE;
1208 }
1209
1210 gboolean
1211 cmenu_cb_poi_route_to(GtkAction *action)
1212 {
1213 poi_info poi;
1214 gdouble lat, lon;
1215
1216 gtk_map_get_menu_latlon(_map, &lat, &lon);
1217 if (poi_select(lat, lon, 4, &poi))
1218         cmenu_route_to(poi.lat, poi.lon);
1219
1220 return TRUE;
1221 }
1222
1223 gboolean
1224 cmenu_cb_poi_distance_to(GtkAction *action)
1225 {
1226 poi_info poi;
1227 gdouble lat, lon;
1228
1229 gtk_map_get_menu_latlon(_map, &lat, &lon);
1230
1231 if (poi_select(lat, lon, 4, &poi))
1232         cmenu_distance_to(poi.lat, poi.lon);
1233
1234 return TRUE;
1235 }
1236
1237 gboolean
1238 cmenu_cb_poi_add_route(GtkAction *action)
1239 {
1240 poi_info poi;
1241 gdouble lat, lon;
1242
1243 gtk_map_get_menu_latlon(_map, &lat, &lon);
1244 if (poi_select(lat, lon, 4, &poi))
1245         path_add_latlon(_route, lat, lon, time(NULL), 0, 0);
1246
1247 return TRUE;
1248 }
1249
1250 gboolean
1251 cmenu_cb_poi_add_way(GtkAction *action)
1252 {
1253 poi_info poi;
1254 gdouble lat, lon;
1255
1256 gtk_map_get_menu_latlon(_map, &lat, &lon);
1257
1258 if (poi_select(lat, lon, 4, &poi))
1259         cmenu_route_add_way(lat, lon);
1260
1261 return TRUE;
1262 }
1263
1264 gboolean
1265 cmenu_cb_poi_show_poi(GtkAction *action)
1266 {
1267 /* XXX: Write this */
1268 return TRUE;
1269 }
1270
1271 gboolean
1272 cmenu_cb_poi_edit_poi(GtkAction *action)
1273 {
1274 poi_info *p;
1275 gdouble lat, lon;
1276
1277 gtk_map_get_menu_latlon(_map, &lat, &lon);
1278 p=poi_find_nearest(lat, lon);
1279 if (!p) {
1280         popup_error(_window, _("No POI found at location."));
1281         return TRUE;
1282 }
1283 poi_edit_dialog(ACTION_EDIT_POI, p);
1284 return TRUE;
1285 }
1286
1287 /***/
1288
1289 gboolean
1290 headphone_button_cb(gpointer data)
1291 {
1292 gint hb_action=0;
1293 switch (hb_action) {
1294 case 1:
1295 #if 0
1296         /* XXX: Add code to add generic POI */
1297         hildon_banner_show_information(_window, NULL, _("POI Added"));
1298 #endif
1299 break;
1300 case 0:
1301 default:
1302         path_insert_mark_text(_track, g_strdup("Mark"));
1303         hildon_banner_show_information(_window, NULL, _("Mark added"));
1304 break;
1305 }
1306 return FALSE;
1307 }