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