1
2
3 #ifdef HAVE_CONFIG_H
4 # include <config.h>
5 #endif
6
7 #include <gtk/gtk.h>
8 #include <math.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <glib.h>
12 #include <glib/gprintf.h>
13
14 #include <gdk/gdkkeysyms.h>
15
16 #include "callbacks.h"
17 #include "interface.h"
18 #include "support.h"
19
20 #include "globals.h"
21 #include "map_management.h"
22 #include "tile_management.h"
23 #include "converter.h"
24 #include "gps_functions.h"
25 #include "friends.h"
26 #include "init.h"
27 #include "geo_photos.h"
28 #include "poi.h"
29 #include "wp.h"
30 #include "tracks.h"
31 #include "route.h"
32 #include "hrm_functions.h"
33
34 /* How many move events must come in for a drag to be recognized: */
35 #define WTFCOUNTER 5
36
37
38 static int wtfcounter=0;
39
40 static int friendfinder_timer = 0;
41 static gboolean distance_mode = FALSE;
42 static gboolean pickpoint_mode = FALSE;
43 static int pickpoint;
44 static int msg_timer = 0;
45 static gboolean msg_pane_visible=TRUE;
46 static gboolean maximized = FALSE;
47
48
49 static GtkWidget *dialog10 = NULL;
50
51
52 static int local_x = 0;
53 static int local_y = 0;
54
55
56 static GdkPixmap *pixmap_photo = NULL;
57 static GdkPixmap *pixmap_photo_big = NULL;
58
59 void do_distance();
60 void do_pickpoint();
61 void move_map(int i);
62
63 void
set_cursor(int type)64 set_cursor(int type)
65 {
66 static GdkCursor *cursor_cross = NULL;
67 static GdkCursor *cursor_default = NULL;
68
69 if(!cursor_cross)
70 {
71 cursor_cross = gdk_cursor_new(GDK_CROSSHAIR);
72 cursor_default = gdk_cursor_new(GDK_LEFT_PTR);
73 }
74
75 if(type == GDK_CROSSHAIR)
76 gdk_window_set_cursor(window1->window, cursor_cross);
77 else
78 gdk_window_set_cursor(window1->window, cursor_default);
79 }
80
81 waypoint_t *selected_wp;
82
83 gboolean
on_drawingarea1_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)84 on_drawingarea1_button_press_event (GtkWidget *widget,
85 GdkEventButton *event,
86 gpointer user_data)
87 {
88 wtfcounter = 0;
89
90 mouse_x = (int) event->x;
91 mouse_y = (int) event->y;
92 local_x = global_x;
93 local_y = global_y;
94
95 selected_wp = find_routepoint (mouse_x, mouse_y);
96
97 return FALSE;
98 }
99
100 gboolean
on_drawingarea1_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)101 on_drawingarea1_button_release_event (GtkWidget *widget,
102 GdkEventButton *event,
103 gpointer user_data)
104 {
105 if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
106
107 GtkWidget *range;
108 int zoom_old;
109 double factor;
110 int width_center, height_center;
111
112
113
114 if(global_zoom<global_zoom_max)
115 {
116 range = lookup_widget(window1, "vscale1");
117
118 width_center = map_drawable->allocation.width / 2;
119 height_center = map_drawable->allocation.height / 2;
120
121 zoom_old = global_zoom;
122
123 global_zoom++;
124 gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
125
126
127
128 factor = 2;
129
130
131 global_x = 2 * global_x + (int)event->x;
132 global_y = 2 * global_y + (int)event->y;
133
134
135 repaint_all();
136 }
137 }
138 else {
139 if(wtfcounter >= WTFCOUNTER)
140 {
141 /* This is the mouse release event
142 of a previous drag: */
143
144 if (!selected_wp) {
145 int mouse_dx, mouse_dy;
146
147 global_x = local_x;
148 global_y = local_y;
149
150 mouse_dx = mouse_x - (int) event->x;
151 mouse_dy = mouse_y - (int) event->y;
152
153 global_x += mouse_dx;
154 global_y += mouse_dy;
155
156 gdk_draw_rectangle (
157 pixmap,
158 widget->style->white_gc,
159 TRUE,
160 0, 0,
161 widget->allocation.width+260,
162 widget->allocation.height+260);
163
164 gtk_widget_queue_draw_area (
165 widget,
166 0,0,widget->allocation.width+260,widget->allocation.height+260);
167
168
169 repaint_all ();
170 } else {
171 selected_wp = NULL;
172 }
173 }
174
175 if (abs(mouse_x - (int) event->x) < 10 && abs(mouse_y - (int) event->y) < 10)
176 {
177 GSList *list;
178 gboolean friend_found = FALSE;
179 gboolean photo_found = FALSE;
180 gboolean poi_found = FALSE;
181 waypoint_t *routepoint;
182
183
184 if(global_show_friends)
185 {
186 for(list = friends_list; list != NULL && !friend_found; list = list->next)
187 {
188 friend_t *f = list->data;
189
190 if( abs(f->screen_x - mouse_x) < 15 &&
191 abs(f->screen_y - mouse_y) < 15)
192 {
193
194 friend_found = TRUE;
195 }
196
197 }
198 }
199
200 if(global_show_photos && !photo_found)
201 {
202 for(list = photo_list; list != NULL && !photo_found; list = list->next)
203 {
204 photo_t *p = list->data;
205
206 if( abs(p->screen_x - mouse_x) < 15 &&
207 abs(p->screen_y - mouse_y) < 15)
208 {
209
210 photo_found = TRUE;
211 }
212
213 }
214 }
215
216 if (global_show_pois )
217 {
218 for(list = poi_list; list != NULL && !poi_found; list = list->next)
219 {
220 poi_t *p = list->data;
221
222 if( abs(p->screen_x - mouse_x) < 15 &&
223 abs(p->screen_y - mouse_y) < 15)
224 {
225
226 poi_found = TRUE;
227 }
228
229 }
230 }
231
232 routepoint = find_routepoint (mouse_x, mouse_y);
233
234 if (!friend_found && !photo_found && !poi_found && !routepoint &&
235 !distance_mode && !pickpoint_mode)
236 {
237
238 gtk_widget_show(menu1);
239
240 gtk_menu_popup (GTK_MENU(menu1), NULL, NULL, NULL, NULL,
241 0, event->time);
242
243 }
244
245 if(distance_mode)
246 do_distance();
247 else if (pickpoint_mode)
248 do_pickpoint();
249 else
250 {
251 if (friend_found)
252 on_item3_activate(NULL, NULL);
253 if (photo_found)
254 on_item10_activate(NULL, NULL);
255 if (poi_found)
256 on_item15_activate(NULL, NULL);
257 if (routepoint) {
258 gtk_widget_show (route_menu);
259 gtk_menu_popup (GTK_MENU (route_menu),
260 NULL, NULL, NULL, NULL,
261 event->button,
262 event->time);
263 }
264 }
265 }
266
267 wtfcounter = 0;
268
269
270 mouse_dx = mouse_dy = 0;
271 drag_started = 0;
272 }
273 return FALSE;
274 }
275
276 gboolean
on_drawingarea1_motion_notify_event(GtkWidget * widget,GdkEventMotion * event,gpointer user_data)277 on_drawingarea1_motion_notify_event (GtkWidget *widget,
278 GdkEventMotion *event,
279 gpointer user_data)
280 {
281 if(global_mapmode)
282 {
283 int x, y, width, height;
284 GdkModifierType state;
285
286 width = map_drawable->allocation.width;
287 height = map_drawable->allocation.height;
288
289 if (event->is_hint)
290 gdk_window_get_pointer (event->window, &x, &y, &state);
291 else
292 {
293 x = event->x;
294 y = event->y;
295 state = event->state;
296 }
297
298 if (state & GDK_BUTTON1_MASK && wtfcounter>=WTFCOUNTER)
299 {
300
301 if (selected_wp) {
302 double lat = pixel2lat (global_zoom, global_y+event->y);
303 double lon = pixel2lon (global_zoom, global_x+event->x);
304 change_waypoint_of_route (selected_wp, lat, lon);
305 repaint_all ();
306 return FALSE;
307 }
308
309 GtkToggleToolButton *autocenter_toggle;
310
311 if(!drag_started)
312 {
313 mouse_x = (int) event->x;
314 mouse_y = (int) event->y;
315 local_x = global_x;
316 local_y = global_y;
317
318 drag_started = 1;
319 }
320 global_autocenter = FALSE;
321
322 mouse_dx = x - mouse_x;
323 mouse_dy = y - mouse_y;
324
325 gdk_draw_drawable (
326 widget->window,
327 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
328 pixmap,
329 0,0,
330 mouse_dx,mouse_dy,
331 -1,-1);
332
333 if(mouse_dx>0)
334 gdk_draw_rectangle (
335 widget->window,
336 widget->style->white_gc,
337 TRUE,
338 0, 0,
339 mouse_dx,
340 widget->allocation.height);
341
342 if (mouse_dy>0)
343 gdk_draw_rectangle (
344 widget->window,
345 widget->style->white_gc,
346 TRUE,
347 0, 0,
348 widget->allocation.width,
349 mouse_dy);
350
351 autocenter_toggle =
352 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1,
353 "button3"));
354 gtk_toggle_tool_button_set_active(autocenter_toggle,
355 FALSE);
356
357 autocenter_toggle =
358 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1,
359 "button56"));
360 gtk_toggle_tool_button_set_active(autocenter_toggle,
361 FALSE);
362
363 }
364 else
365 wtfcounter++;
366 }
367
368 return FALSE;
369 }
370
371
372 gboolean
on_drawingarea1_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)373 on_drawingarea1_configure_event (GtkWidget *widget,
374 GdkEventConfigure *event,
375 gpointer user_data)
376 {
377 map_drawable = widget;
378
379 global_drawingarea_width = widget->allocation.width;
380 global_drawingarea_height = widget->allocation.height;
381
382
383 if (pixmap)
384 g_object_unref (pixmap);
385
386 pixmap = gdk_pixmap_new (
387 widget->window,
388 widget->allocation.width+260,
389 widget->allocation.height+260,
390 -1);
391
392 if (!pixmap)
393 {
394 printf("aieee: pixmap NULL\n");
395 }
396
397 gdk_draw_rectangle (
398 pixmap,
399 widget->style->white_gc,
400 TRUE,
401 0, 0,
402 widget->allocation.width+260,
403 widget->allocation.height+260);
404
405 gtk_widget_queue_draw_area (
406 widget,
407 0,0,widget->allocation.width+260,widget->allocation.height+260);
408
409 repaint_all();
410
411 return FALSE;
412 }
413
414
415 gboolean
on_drawingarea1_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)416 on_drawingarea1_expose_event (GtkWidget *widget,
417 GdkEventExpose *event,
418 gpointer user_data)
419 {
420
421
422
423 gdk_draw_drawable (
424 widget->window,
425 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
426 pixmap,
427 event->area.x, event->area.y,
428 event->area.x, event->area.y,
429 event->area.width, event->area.height);
430
431 osd_speed(TRUE);
432 osd_hrm(TRUE);
433 map_scale_indicator();
434
435 return FALSE;
436 }
437
438 void
on_button1_clicked(GtkToggleToolButton * button,gpointer user_data)439 on_button1_clicked (GtkToggleToolButton *button,
440 gpointer user_data)
441 {
442 maximized = gtk_toggle_tool_button_get_active (button);
443
444 if(maximized)
445 {
446 gtk_window_fullscreen(GTK_WINDOW(window1));
447 fill_tiles_pixel(global_x, global_y, global_zoom, FALSE);
448 }
449 else
450 {
451 gtk_window_unfullscreen(GTK_WINDOW(window1));
452 }
453 }
454
455
456
457 void
on_vscale1_value_changed(GtkRange * range,gpointer user_data)458 on_vscale1_value_changed (GtkRange *range,
459 gpointer user_data)
460 {
461
462
463 }
464
465 void
on_button4_clicked(GtkButton * button,gpointer user_data)466 on_button4_clicked (GtkButton *button,
467 gpointer user_data)
468 {
469 GtkWidget *range;
470
471
472 int zoom_old;
473 double factor;
474 int width_center, height_center;
475
476 if(global_zoom<global_zoom_max)
477 {
478 range = lookup_widget(window1, "vscale1");
479
480 width_center = map_drawable->allocation.width / 2;
481 height_center = map_drawable->allocation.height / 2;
482
483 zoom_old = global_zoom;
484
485 global_zoom++;
486 gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
487 factor = exp(global_zoom * M_LN2)/exp2(zoom_old);
488
489 global_x = ((global_x + width_center) * factor) - width_center;
490 global_y = ((global_y + height_center) * factor) - height_center;
491
492
493 repaint_all();
494 }
495 }
496
497
498 void
on_button3_clicked(GtkToggleToolButton * button,gpointer user_data)499 on_button3_clicked (GtkToggleToolButton *button,
500 gpointer user_data)
501 {
502 global_autocenter = gtk_toggle_tool_button_get_active(button);
503
504 if (!global_autocenter)
505 return;
506
507 if(gpsdata) {
508 if(isnan(gpsdata->fix.latitude) == 0 &&
509 isnan(gpsdata->fix.longitude)== 0 &&
510 gpsdata->fix.latitude !=0 &&
511 gpsdata->fix.longitude!=0) {
512 set_mapcenter(gpsdata->fix.latitude, gpsdata->fix.longitude, global_zoom);
513 }
514 }
515 }
516
517 gboolean
on_window1_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)518 on_window1_delete_event (GtkWidget *widget,
519 GdkEvent *event,
520 gpointer user_data)
521 {
522 track_log_close ();
523 gtk_main_quit();
524
525 return FALSE;
526 }
527
528
529 gboolean
on_window1_destroy_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)530 on_window1_destroy_event (GtkWidget *widget,
531 GdkEvent *event,
532 gpointer user_data)
533 {
534 track_log_close ();
535 gtk_main_quit();
536
537 return FALSE;
538 }
539
540
541 void
on_button5_clicked(GtkButton * button,gpointer user_data)542 on_button5_clicked (GtkButton *button,
543 gpointer user_data)
544 {
545 int zoom_old;
546 float factor;
547 int width_center, height_center;
548 GtkWidget *range;
549 if(global_zoom>2)
550 {
551 range = lookup_widget(window1, "vscale1");
552
553 width_center = map_drawable->allocation.width / 2;
554 height_center = map_drawable->allocation.height / 2;
555
556 zoom_old = global_zoom;
557
558 global_zoom--;
559 gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
560
561 factor = exp(global_zoom * M_LN2)/exp(zoom_old * M_LN2);
562
563 global_x = ((global_x + width_center) * factor) - width_center;
564 global_y = ((global_y + height_center) * factor) - height_center;
565
566 repaint_all();
567 }
568 }
569
570 gboolean
on_vscale1_change_value(GtkRange * range,GtkScrollType scroll,gdouble value,gpointer user_data)571 on_vscale1_change_value (GtkRange *range,
572 GtkScrollType scroll,
573 gdouble value,
574 gpointer user_data)
575 {
576
577 return FALSE;
578 }
579
580 gboolean
on_vscale1_button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)581 on_vscale1_button_press_event (GtkWidget *widget,
582 GdkEventButton *event,
583 gpointer user_data)
584 {
585
586 return FALSE;
587 }
588
589
590 gboolean
on_vscale1_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)591 on_vscale1_button_release_event (GtkWidget *widget,
592 GdkEventButton *event,
593 gpointer user_data)
594 {
595 int zoom_old;
596 float factor;
597 int width_center, height_center;
598
599 width_center = map_drawable->allocation.width / 2;
600 height_center = map_drawable->allocation.height / 2;
601
602 zoom_old = global_zoom;
603
604 global_zoom = gtk_range_get_value(GTK_RANGE(widget));
605 factor = exp(global_zoom * M_LN2)/exp(zoom_old * M_LN2);
606
607 global_x = ((global_x + width_center) * factor) - width_center;
608 global_y = ((global_y + height_center) * factor) - height_center;
609
610 repaint_all();
611
612 return FALSE;
613 }
614
615
616 void
on_combobox1_changed(GtkComboBox * combobox,gpointer user_data)617 on_combobox1_changed (GtkComboBox *combobox,
618 gpointer user_data)
619 {
620 GSList *list;
621 gchar *reponame_combo;
622 gboolean success = FALSE;
623 static gboolean first_run = TRUE;
624
625
626 reponame_combo = gtk_combo_box_get_active_text(combobox);
627
628 global_curr_reponame = g_strdup(reponame_combo);
629
630
631 if(!global_curr_reponame)
632 {
633 global_curr_reponame = g_strdup("OSM");
634 printf("YOUR DISTRIBUTION SUCKS BIGTIME\n");
635 }
636
637
638 for(list = global_repo_list; list != NULL; list = list->next)
639 {
640 repo_t *repo;
641 gchar *reponame;
642
643 repo = list->data;
644 reponame = g_strdup(repo->name);
645
646 if( g_strrstr(reponame,global_curr_reponame) != NULL &&
647 strlen(reponame) == strlen(global_curr_reponame)
648 )
649 {
650 global_curr_repo = list;
651 }
652 }
653
654
655 success = g_settings_set_string(
656 global_settings,
657 "repo-name",
658 global_curr_reponame);
659
660 global_repo_nr = gtk_combo_box_get_active(combobox);
661
662
663
664 if(first_run) {
665 first_run = FALSE;
666 }
667 else
668 repaint_all();
669 }
670
671 void
on_dialog1_close(GtkDialog * dialog,gpointer user_data)672 on_dialog1_close (GtkDialog *dialog,
673 gpointer user_data)
674 {
675 }
676
677
678 void
on_dialog1_response(GtkDialog * dialog,gint response_id,gpointer user_data)679 on_dialog1_response (GtkDialog *dialog,
680 gint response_id,
681 gpointer user_data)
682 {
683 }
684
685
686 void
on_cancelbutton1_clicked(GtkButton * button,gpointer user_data)687 on_cancelbutton1_clicked (GtkButton *button,
688 gpointer user_data)
689 {
690 gtk_widget_hide(dialog1);
691 }
692
693
694 void
on_okbutton1_clicked(GtkButton * button,gpointer user_data)695 on_okbutton1_clicked (GtkButton *button,
696 gpointer user_data)
697 {
698 GtkWidget *entry_repo;
699 GtkWidget *combobox;
700 GtkWidget *entry_uri;
701 GtkWidget *entry_dir;
702 GtkWidget *togglebutton;
703 const gchar *reponame, *uri, *dir;
704 gboolean reversed;
705 repo_t *repo = g_new0(repo_t, 1);
706
707
708 entry_repo = lookup_widget(dialog1, "entry5");
709 entry_uri = lookup_widget(dialog1, "entry20");
710 entry_dir = lookup_widget(dialog1, "entry21");
711 togglebutton = lookup_widget(dialog1, "checkbutton12");
712 combobox = lookup_widget(window1, "combobox1");
713
714 reponame = gtk_entry_get_text(GTK_ENTRY(entry_repo));
715 uri = gtk_entry_get_text(GTK_ENTRY(entry_uri));
716 dir = gtk_entry_get_text(GTK_ENTRY(entry_dir));
717 reversed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton));
718
719 gtk_combo_box_append_text (GTK_COMBO_BOX(combobox), g_strdup(reponame));
720 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), global_repo_cnt);
721 global_repo_cnt++;
722
723
724 repo->name = g_strdup(reponame);
725 repo->dir = g_strdup(dir);
726 repo->uri = g_strdup(uri);
727 repo->inverted_zoom = reversed;
728
729 global_repo_list = g_slist_prepend(global_repo_list, repo);
730 global_curr_repo = global_repo_list;
731
732 settings_set_repolist();
733
734 gtk_widget_hide(dialog1);
735 }
736
737
738 void
on_button7_clicked(GtkButton * button,gpointer user_data)739 on_button7_clicked (GtkButton *button,
740 gpointer user_data)
741 {
742 GtkWidget *entry_repo;
743 GtkWidget *entry_uri;
744 GtkWidget *entry_dir;
745 GtkWidget *togglebutton;
746
747 dialog1 = glade_xml_get_widget (gladexml, "dialog1");
748
749 entry_repo = lookup_widget(dialog1, "entry5");
750 entry_uri = lookup_widget(dialog1, "entry20");
751 entry_dir = lookup_widget(dialog1, "entry21");
752 togglebutton = lookup_widget(dialog1, "checkbutton12");
753
754 gtk_entry_set_text(GTK_ENTRY(entry_repo), "");
755 gtk_entry_set_text(GTK_ENTRY(entry_uri), "");
756 gtk_entry_set_text(GTK_ENTRY(entry_dir), "");
757 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton), FALSE);
758
759 gtk_widget_show(dialog1);
760 }
761
762 void
on_button8_clicked(GtkButton * button,gpointer user_data)763 on_button8_clicked (GtkButton *button,
764 gpointer user_data)
765 {
766 trip_distance = 0;
767 trip_starttime = 0;
768 trip_time = 0;
769 trip_maxspeed = 0;
770 }
771
772 void
on_checkbutton2_toggled(GtkToggleButton * togglebutton,gpointer user_data)773 on_checkbutton2_toggled (GtkToggleButton *togglebutton,
774 gpointer user_data)
775 {
776 gboolean toggled;
777 gboolean success = FALSE;
778
779 toggled = gtk_toggle_button_get_active(togglebutton);
780 global_auto_download = toggled;
781
782 success = g_settings_set_boolean(
783 global_settings,
784 "auto-download",
785 global_auto_download);
786
787 }
788
789
790 void
on_button9_clicked(GtkButton * button,gpointer user_data)791 on_button9_clicked (GtkButton *button,
792 gpointer user_data)
793 {
794 GtkWidget *entry_server, *entry_port;
795 const gchar *server, *port;
796
797 entry_server = lookup_widget(window1, "entry3");
798 entry_port = lookup_widget(window1, "entry4");
799 server = gtk_entry_get_text(GTK_ENTRY(entry_server));
800 port = gtk_entry_get_text(GTK_ENTRY(entry_port));
801 global_server = g_strdup(server);
802 global_port = g_strdup(port);
803
804 reset_gpsd_io ();
805 }
806
807
808
809 void
on_button11_clicked(GtkButton * button,gpointer user_data)810 on_button11_clicked (GtkButton *button,
811 gpointer user_data)
812 {
813 GtkWidget *widget;
814 gboolean success = FALSE;
815
816
817 if(!global_fftimer_running)
818 {
819 update_position();
820 send_message(NULL);
821 friendfinder_timer = g_timeout_add_seconds(global_ffupdate_interval/1000,update_position,NULL);
822 msg_timer = g_timeout_add_seconds(global_ffupdate_interval/1000,send_message,NULL);
823
824 widget = lookup_widget(window1, "image24");
825 gtk_widget_show(widget);
826
827 gtk_button_set_label (button, _("Stop"));
828
829 widget = lookup_widget(menu1, "item19");
830 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
831
832 global_fftimer_running = TRUE;
833 }
834
835
836
837 else
838 {
839 widget = lookup_widget(window1, "image24");
840 gtk_widget_hide(widget);
841
842 g_source_remove(friendfinder_timer);
843 g_source_remove(msg_timer);
844 friendfinder_timer = 0;
845 msg_timer =0;
846 global_fftimer_running = FALSE;
847
848 gtk_button_set_label (button, _("Share!"));
849 }
850
851
852 success = g_settings_set_boolean(
853 global_settings,
854 "fftimer-running",
855 global_fftimer_running);
856
857 global_show_friends = TRUE;
858 }
859
860
861 void
on_item3_activate(GtkMenuItem * menuitem,gpointer user_data)862 on_item3_activate (GtkMenuItem *menuitem,
863 gpointer user_data)
864 {
865 GSList *list;
866 GladeXML *gladexml;
867 GtkWidget *label, *window, *friend_box, *widget, *hseparator;
868 gchar buffer[8192];
869 gboolean friend_found = FALSE;
870 float lat, lon,lat_deg,lon_deg;
871 float distance=0;
872
873 gladexml = glade_xml_new (gladefile, "window8", GETTEXT_PACKAGE);
874 glade_xml_signal_autoconnect (gladexml);
875 window = glade_xml_get_widget (gladexml, "window8");
876 g_signal_connect_swapped (window, "destroy",
877 G_CALLBACK (g_object_unref), gladexml);
878
879 widget = lookup_widget(window, "vbox35");
880 gtk_widget_show (window);
881
882 lat = pixel2lat(global_zoom, global_y+mouse_y);
883 lon = pixel2lon(global_zoom, global_x+mouse_x);
884
885 lat_deg = rad2deg(lat);
886 lon_deg = rad2deg(lon);
887
888 if(gpsdata !=NULL && !global_myposition.lat && !global_myposition.lon)
889 {
890 distance = 6371.0 *
891 acos(sin(deg2rad(gpsdata->fix.latitude)) *
892 sin(lat) +
893
894 cos(deg2rad(gpsdata->fix.latitude)) *
895 cos(lat) *
896 cos(lon - deg2rad(gpsdata->fix.longitude)) );
897 }
898 else if(global_myposition.lat && global_myposition.lon)
899 {
900 distance = 6371.0 *
901 acos(sin(deg2rad(global_myposition.lat)) *
902 sin(lat) +
903
904 cos(deg2rad(global_myposition.lat)) *
905 cos(lat) *
906 cos(lon - deg2rad(global_myposition.lon)) );
907
908 }
909
910 g_sprintf (buffer, _("<b><i>Distance:</i></b> %.3fkm\n"), distance);
911
912 for(list = friends_list; list != NULL; list = list->next)
913 {
914 friend_t *f = list->data;
915
916 if( abs(f->screen_x - mouse_x) < 15 &&
917 abs(f->screen_y - mouse_y) < 15)
918 {
919 friend_box = create_friend_box(f);
920
921 gtk_box_pack_start (GTK_BOX (widget), friend_box, FALSE, FALSE, 0);
922
923 hseparator = gtk_hseparator_new ();
924 gtk_widget_show (hseparator);
925 gtk_box_pack_start (GTK_BOX (widget), hseparator, FALSE, FALSE, 0);
926
927 friend_found = TRUE;
928 }
929
930 }
931
932 if (!friend_found)
933 g_sprintf (buffer, _("No friends at or near this position"));
934
935
936 label = lookup_widget(window,"label119");
937 gtk_label_set_label(GTK_LABEL(label),buffer);
938 }
939
940 void
on_item4_activate(GtkMenuItem * menuitem,gpointer user_data)941 on_item4_activate (GtkMenuItem *menuitem,
942 gpointer user_data)
943 {
944 GtkWidget *label;
945 gchar buffer[512]; gchar *bufp;
946 gchar latlon[64];
947 static float start_lat=0, start_lon=0;
948 static float overall_distance = 0;
949 static int start_x=0, start_y=0;
950 float lat, lon,lat_deg,lon_deg, bearing=0;
951 float distance=0;
952 double unit_conv = 1;
953 static gchar distunit[3];
954
955 if(!distance_mode)
956 overall_distance = 0.0;
957
958 set_cursor(GDK_CROSSHAIR);
959
960
961
962 lat = pixel2lat(global_zoom, global_y+mouse_y);
963 lon = pixel2lon(global_zoom, global_x+mouse_x);
964
965 lat_deg = rad2deg(lat);
966 lon_deg = rad2deg(lon);
967
968 switch (global_latlon_unit)
969 {
970 case 0:
971 g_sprintf(latlon, "%f - %f", lat_deg, lon_deg);
972 break;
973 case 1:
974 g_sprintf(latlon, "%s %s",
975 latdeg2latmin(lat_deg),
976 londeg2lonmin(lon_deg));
977 break;
978 case 2:
979 g_sprintf(latlon, "%s %s",
980 latdeg2latsec(lat_deg),
981 londeg2lonsec(lon_deg));
982 }
983
984
985 if(global_speed_unit==1)
986 {
987 unit_conv = 1.0/1.609344;
988 g_sprintf(distunit, "%s", "m");
989 }
990 else if(global_speed_unit==2)
991 {
992 unit_conv = 1.0/1.852;
993 g_sprintf(distunit, "%s", "NM");
994 }
995 else
996 {
997 g_sprintf(distunit, "%s", "km");
998 }
999
1000
1001
1002 if(distance_mode)
1003 {
1004 distance = 6371.0 *
1005 acos(sin(deg2rad(start_lat)) *
1006 sin(lat) +
1007
1008 cos(deg2rad(start_lat)) *
1009 cos(lat) *
1010 cos(lon - deg2rad(start_lon)) );
1011
1012 bearing = get_bearing(deg2rad(start_lat), deg2rad(start_lon), lat, lon);
1013 }
1014 else if(gpsdata !=NULL && gpsdata->fix.latitude)
1015 {
1016 distance = 6371.0 *
1017 acos(sin(deg2rad(gpsdata->fix.latitude)) *
1018 sin(lat) +
1019
1020 cos(deg2rad(gpsdata->fix.latitude)) *
1021 cos(lat) *
1022 cos(lon - deg2rad(gpsdata->fix.longitude)) );
1023 }
1024
1025 if(distance_mode)
1026 overall_distance += distance;
1027
1028
1029 gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), latlon, -1);
1030
1031
1032
1033 label = lookup_widget(window2,"label64");
1034
1035 bufp = buffer;
1036 bufp += g_sprintf (bufp, _("<b>This point:</b>\n%s\n"
1037 "<small><i>(coords auto-copied to clipboard)\n</i></small>\n"),
1038 latlon);
1039
1040 if (gpsdata && gpsdata->fix.latitude)
1041 {
1042 bufp += g_sprintf (bufp, _("<b>Bearing:</b>\n%.1f°\n"),
1043 bearing/M_PI*180);
1044
1045 if (!distance_mode)
1046 {
1047 bufp += g_sprintf (bufp, _("<b>Distance from your location:</b>\n%.2f%s\n"),
1048 distance*unit_conv,
1049 distunit);
1050 }
1051 }
1052
1053 if (!distance_mode)
1054 {
1055 bufp += g_sprintf (bufp, _("Click another point for distance"));
1056 }
1057 else
1058 {
1059 bufp += g_sprintf (bufp, _("<b>Distance from last point:</b>\n%.2f%s\n"),
1060 distance*unit_conv, distunit);
1061 bufp += g_sprintf (bufp, _("<b>Overall Distance:</b>\n%.2f%s"),
1062 overall_distance*unit_conv, distunit);
1063 }
1064
1065 gtk_label_set_label(GTK_LABEL(label),buffer);
1066 gtk_widget_show (window2);
1067
1068
1069
1070 if(distance_mode)
1071 {
1072
1073 int pixel_x, pixel_y, x, y;
1074 float lt, ln;
1075
1076
1077 GdkColor color;
1078 GdkGC *gc;
1079
1080 gc = gdk_gc_new(pixmap);
1081 color.green = 0;
1082 color.blue = 50000;
1083 color.red = 0;
1084 gdk_gc_set_rgb_fg_color(gc, &color);
1085 gdk_gc_set_line_attributes(
1086 gc, 5, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND);
1087
1088
1089
1090
1091 lt = deg2rad(start_lat);
1092 ln = deg2rad(start_lon);
1093 pixel_x = lon2pixel(global_zoom, ln);
1094 pixel_y = lat2pixel(global_zoom, lt);
1095 x = pixel_x - global_x;
1096 y = pixel_y - global_y;
1097
1098
1099
1100 gdk_draw_line (pixmap, gc, x, y, mouse_x, mouse_y);
1101
1102 gtk_widget_queue_draw_area (
1103 map_drawable,
1104 ((x > mouse_x) ? mouse_x : x) - 4,
1105 ((y > mouse_y) ? mouse_y : y) - 4,
1106 abs(mouse_x - x) + 8,
1107 abs(mouse_y - y) + 8);
1108 }
1109 else
1110 {
1111
1112
1113 GdkColor color;
1114 GdkGC *gc;
1115
1116 gc = gdk_gc_new(pixmap);
1117 color.green = 20000;
1118 color.blue = 20000;
1119 color.red = 65000;
1120 gdk_gc_set_rgb_fg_color(gc, &color);
1121 gdk_gc_set_line_attributes(
1122 gc, 5, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND);
1123
1124
1125
1126
1127 gdk_draw_arc (
1128 pixmap,
1129
1130 gc,
1131 TRUE,
1132 mouse_x-8, mouse_y-8,
1133 16,16,
1134 0,23040);
1135
1136 gtk_widget_queue_draw_area (
1137 map_drawable,
1138 mouse_x - 8,
1139 mouse_y - 8,
1140 mouse_x + 16,
1141 mouse_y + 16);
1142
1143 }
1144
1145
1146 start_x = mouse_x;
1147 start_y = mouse_y;
1148 start_lat = lat_deg;
1149 start_lon = lon_deg;
1150
1151
1152 distance_mode = TRUE;
1153
1154 }
1155
1156
1157
1158 void
on_button14_clicked(GtkButton * button,gpointer user_data)1159 on_button14_clicked (GtkButton *button,
1160 gpointer user_data)
1161 {
1162 GtkWidget *window;
1163 window = lookup_widget(GTK_WIDGET(button), "window2");
1164 gtk_widget_hide(window);
1165
1166 distance_mode = FALSE;
1167 set_cursor(GDK_HAND2);
1168 repaint_all();
1169 }
1170
1171 gboolean
on_item5_activate(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1172 on_item5_activate (GtkWidget *widget,
1173 GdkEventButton *event,
1174 gpointer user_data)
1175 {
1176
1177 GtkWidget *label;
1178 gchar buffer[512];
1179 float lat, lon,lat_deg,lon_deg;
1180
1181 lat = pixel2lat(global_zoom, global_y+mouse_y);
1182 lon = pixel2lon(global_zoom, global_x+mouse_x);
1183
1184 lat_deg = rad2deg(lat);
1185 lon_deg = rad2deg(lon);
1186
1187 global_myposition.lat = lat_deg;
1188 global_myposition.lon = lon_deg;
1189
1190 label = lookup_widget(window2,"label64");
1191
1192 g_sprintf (buffer, _("<b>Manually set position</b>\n\n"
1193 "This point:\n\n <i>%f %f</i>\n\n"
1194 "will now be used as your location\n"
1195 "for the friend finder service."),
1196 global_myposition.lat,
1197 global_myposition.lon);
1198
1199 gtk_label_set_label(GTK_LABEL(label),buffer);
1200 gtk_widget_show (window2);
1201
1202 g_settings_set_double(
1203 global_settings,
1204 "myposition-lat",
1205 global_myposition.lat);
1206
1207 g_settings_set_double(
1208 global_settings,
1209 "myposition-lon",
1210 global_myposition.lon);
1211
1212 paint_myposition();
1213
1214 return FALSE;
1215 }
1216
1217 gboolean
on_drawinarea1_scroll_event(GtkWidget * widget,GdkEventScroll * event,gpointer user_data)1218 on_drawinarea1_scroll_event (GtkWidget *widget,
1219 GdkEventScroll *event,
1220 gpointer user_data)
1221 {
1222 if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
1223 return TRUE;
1224 }
1225 else
1226 {
1227 GtkWidget *range;
1228 int zoom_old;
1229 double factor;
1230 int width_center, height_center;
1231 static int slowpad = 0;
1232
1233 if (event->direction == GDK_SCROLL_UP && slowpad % 2 ==0)
1234 {
1235 slowpad++;
1236
1237 if(global_zoom<global_zoom_max)
1238 {
1239 range = lookup_widget(window1, "vscale1");
1240
1241 width_center = map_drawable->allocation.width / 2;
1242 height_center = map_drawable->allocation.height / 2;
1243
1244 zoom_old = global_zoom;
1245
1246 global_zoom++;
1247 gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
1248
1249
1250
1251 factor = 2;
1252
1253
1254 global_x = 2 * global_x + (int)event->x;
1255 global_y = 2 * global_y + (int)event->y;
1256
1257
1258 repaint_all();
1259 }
1260 }
1261 else if (event->direction == GDK_SCROLL_DOWN && slowpad % 2 ==0)
1262 {
1263 slowpad++;
1264
1265 if(global_zoom>2)
1266 {
1267 range = lookup_widget(window1, "vscale1");
1268
1269 width_center = map_drawable->allocation.width / 2;
1270 height_center = map_drawable->allocation.height / 2;
1271
1272 zoom_old = global_zoom;
1273
1274 global_zoom--;
1275 gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
1276
1277 factor = exp(global_zoom * M_LN2)/exp(zoom_old * M_LN2);
1278
1279 global_x = global_x/2 - (int)event->x/2;
1280 global_y = global_y/2 - (int)event->y/2;
1281
1282 repaint_all();
1283 }
1284 }
1285 else slowpad++;
1286
1287 return TRUE;
1288 }
1289
1290
1291 }
1292
1293 void
on_button15_clicked(GtkButton * button,gpointer user_data)1294 on_button15_clicked (GtkButton *button,
1295 gpointer user_data)
1296 {
1297 trip_counter_on = (trip_counter_on) ? FALSE : TRUE;
1298
1299 if(trip_counter_on)
1300 gtk_button_set_label (button, _("Stop"));
1301 else
1302 gtk_button_set_label (button, _("Resume"));
1303 }
1304
1305 void
on_entry7_changed(GtkEditable * editable,gpointer user_data)1306 on_entry7_changed (GtkEditable *editable,
1307 gpointer user_data)
1308 {
1309 GtkWidget *nick;
1310 const gchar *n;
1311 gboolean success = FALSE;
1312
1313 nick = lookup_widget(window1, "entry7");
1314
1315 n = gtk_entry_get_text(GTK_ENTRY(nick));
1316
1317 success = g_settings_set_string(
1318 global_settings,
1319 "nick",
1320 n);
1321 }
1322
1323
1324 void
on_entry8_changed(GtkEditable * editable,gpointer user_data)1325 on_entry8_changed (GtkEditable *editable,
1326 gpointer user_data)
1327 {
1328 GtkWidget *pass;
1329 const gchar *p;
1330 gboolean success = FALSE;
1331
1332 pass = lookup_widget(window1, "entry8");
1333
1334 p = gtk_entry_get_text(GTK_ENTRY(pass));
1335
1336
1337 success = g_settings_set_string(
1338 global_settings,
1339 "pass",
1340 p);
1341
1342 }
1343
1344 void
on_button13_clicked(GtkButton * button,gpointer user_data)1345 on_button13_clicked (GtkButton *button,
1346 gpointer user_data)
1347 {
1348 register_nick();
1349 }
1350
1351
1352
1353 void
on_button19_clicked(GtkButton * button,gpointer user_data)1354 on_button19_clicked (GtkButton *button,
1355 gpointer user_data)
1356 {
1357
1358 track_log_close();
1359 track_log_open();
1360
1361 }
1362
1363
1364 void
on_button20_clicked(GtkButton * button,gpointer user_data)1365 on_button20_clicked (GtkButton *button,
1366 gpointer user_data)
1367 {
1368 GtkWidget *dialog3, *entry;
1369
1370 dialog3 = glade_xml_get_widget (gladexml, "dialog3");
1371 entry = lookup_widget(dialog3, "entry12");
1372 gtk_entry_set_text(GTK_ENTRY(entry), global_track_dir);
1373
1374 gtk_widget_show(dialog3);
1375 }
1376
1377 void
on_cancelbutton2_clicked(GtkButton * button,gpointer user_data)1378 on_cancelbutton2_clicked (GtkButton *button,
1379 gpointer user_data)
1380 {
1381 GtkWidget *dialog3;
1382
1383 dialog3 = lookup_widget(GTK_WIDGET(button), "dialog3");
1384
1385 gtk_widget_hide(dialog3);
1386 }
1387
1388
1389 void
on_okbutton2_clicked(GtkButton * button,gpointer user_data)1390 on_okbutton2_clicked (GtkButton *button,
1391 gpointer user_data)
1392 {
1393 GtkWidget *dialog3;
1394 GtkEntry *entry;
1395 gint mkres;
1396 gboolean success = FALSE;
1397 int result;
1398
1399
1400 entry = (GtkEntry *)lookup_widget(GTK_WIDGET(button), "entry12");
1401 global_track_dir = g_strconcat(gtk_entry_get_text(entry),"/",NULL);
1402
1403 result = strncmp(global_track_dir, "~", 1);
1404
1405 if(!result)
1406 {
1407 char *sub_home, *home_dir;
1408
1409 strsep(&global_track_dir, "~");
1410 sub_home = g_strdup(strsep(&global_track_dir, "~"));
1411 home_dir = getenv("HOME");
1412
1413 g_free(global_track_dir);
1414 global_track_dir = g_strconcat(home_dir, sub_home, NULL);
1415
1416 g_free(sub_home);
1417 }
1418
1419 mkres = g_mkdir_with_parents(global_track_dir,0700);
1420 if(mkres==-1) {
1421 perror("mkdir........");
1422 }
1423
1424 success = g_settings_set_string(
1425 global_settings,
1426 "track-dir",
1427 global_track_dir);
1428
1429 dialog3 = lookup_widget(GTK_WIDGET(button), "dialog3");
1430
1431 gtk_widget_hide(dialog3);
1432 }
1433
1434
1435
1436 void
on_item6_activate(GtkMenuItem * menuitem,gpointer user_data)1437 on_item6_activate (GtkMenuItem *menuitem,
1438 gpointer user_data)
1439 {
1440
1441 }
1442
1443
1444 gboolean
on_item7_activate(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1445 on_item7_activate (GtkWidget *widget,
1446 GdkEventButton *event,
1447 gpointer user_data)
1448 {
1449 global_myposition.lat = global_myposition.lon = 0;
1450
1451 g_settings_set_double(
1452 global_settings,
1453 "myposition-lat",
1454 0);
1455
1456 g_settings_set_double(
1457 global_settings,
1458 "myposition-lon",
1459 0);
1460
1461 repaint_all();
1462
1463 return FALSE;
1464 }
1465
1466 void
on_item8_activate(GtkMenuItem * menuitem,gpointer user_data)1467 on_item8_activate (GtkMenuItem *menuitem,
1468 gpointer user_data)
1469 {
1470 GtkWidget *dialog4;
1471
1472 dialog4 = glade_xml_get_widget (gladexml, "dialog4");
1473 gtk_widget_show(dialog4);
1474 }
1475
1476 void
on_cancelbutton3_clicked(GtkButton * button,gpointer user_data)1477 on_cancelbutton3_clicked (GtkButton *button,
1478 gpointer user_data)
1479 {
1480 GtkWidget *dialog;
1481
1482 dialog = lookup_widget(GTK_WIDGET(button), "dialog4");
1483 gtk_widget_hide(dialog);
1484 }
1485
1486
1487 void
on_okbutton3_clicked(GtkButton * button,gpointer user_data)1488 on_okbutton3_clicked (GtkButton *button,
1489 gpointer user_data)
1490 {
1491 GtkWidget *dialog;
1492
1493 dialog = lookup_widget(GTK_WIDGET(button), "dialog4");
1494 cb_download_maps(dialog);
1495 }
1496
1497
1498 gboolean
on_drawingarea2_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)1499 on_drawingarea2_configure_event (GtkWidget *widget,
1500 GdkEventConfigure *event,
1501 gpointer user_data)
1502 {
1503 if (!pixmap_photo)
1504 pixmap_photo = gdk_pixmap_new (
1505 widget->window,
1506 widget->allocation.width,
1507 widget->allocation.height,
1508 -1);
1509
1510 if (!pixmap_photo)
1511 {
1512 printf("aieee: pixmap_photo NULL\n");
1513 }
1514
1515 return FALSE;
1516 }
1517
1518
1519 gboolean
on_drawingarea2_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)1520 on_drawingarea2_expose_event (GtkWidget *widget,
1521 GdkEventExpose *event,
1522 gpointer user_data)
1523 {
1524 gdk_draw_drawable (
1525 widget->window,
1526 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
1527 pixmap_photo,
1528 event->area.x, event->area.y,
1529 event->area.x, event->area.y,
1530 event->area.width, event->area.height);
1531
1532
1533 return FALSE;
1534 }
1535
1536
1537
1538 void
on_item10_activate(GtkMenuItem * menuitem,gpointer user_data)1539 on_item10_activate (GtkMenuItem *menuitem,
1540 gpointer user_data)
1541 {
1542 GtkWidget *label, *widget;
1543 GtkWidget *drawingarea2;
1544
1545 static gulong hd1 = 0, hd2 = 0;
1546
1547 GSList *list;
1548 gchar buffer[512];
1549 gchar *photo_file = NULL;
1550 gboolean photo_found = FALSE;
1551
1552 GdkPixbuf *photo = NULL;
1553 GError *error = NULL;
1554 GdkGC *gc;
1555
1556 waypoint_t *wp = g_new0(waypoint_t,1);
1557
1558 gtk_widget_show(window3);
1559
1560 drawingarea2 = lookup_widget(window3,"drawingarea2");
1561
1562
1563
1564
1565
1566
1567
1568 label = lookup_widget(window3,"label104");
1569
1570
1571
1572
1573
1574
1575 for(list = photo_list; list != NULL; list = list->next)
1576 {
1577 photo_t *p = list->data;
1578
1579 if(abs(p->screen_x - mouse_x) < 15 &&
1580 abs(p->screen_y - mouse_y) < 15 &&
1581 !photo_found && !photo)
1582 {
1583 g_sprintf(buffer,
1584 "%s ",
1585 p->name);
1586 photo_found = TRUE;
1587 wp->lat = deg2rad(p->lat);
1588 wp->lon = deg2rad(p->lon);
1589
1590
1591 photo = gdk_pixbuf_new_from_file_at_size (
1592 p->filename, 240,-1,
1593 &error);
1594 if(!photo)
1595 {
1596 printf ("+++++++++++++ FOTO NOT FOUND +++++++++\n");
1597 g_sprintf (buffer, _("File not found"));
1598 }
1599 else
1600 {
1601 photo_file = p->filename;
1602
1603 gc = gdk_gc_new(pixmap_photo);
1604
1605 gdk_draw_rectangle (
1606 pixmap_photo,
1607 drawingarea2->style->white_gc,
1608 TRUE,
1609 0, 0,
1610 drawingarea2->allocation.width,
1611 drawingarea2->allocation.height);
1612
1613 gdk_draw_pixbuf (
1614 pixmap_photo,
1615 gc,
1616 photo,
1617 0,0,
1618 0, 0,
1619 -1,-1,
1620 GDK_RGB_DITHER_NONE, 0, 0);
1621
1622 gdk_draw_drawable (
1623 drawingarea2->window,
1624 drawingarea2->style->fg_gc[GTK_WIDGET_STATE (drawingarea2)],
1625 pixmap_photo,
1626 0,0,
1627 0,0,
1628 -1,-1);
1629
1630 gtk_widget_queue_draw_area (
1631 drawingarea2,
1632 0, 0,
1633 80,80);
1634
1635 }
1636
1637
1638
1639 }
1640
1641 }
1642
1643 if(!photo_found)
1644 g_sprintf (buffer, _("No Geo Photo found"));
1645
1646 gtk_label_set_text(GTK_LABEL(label),buffer);
1647
1648 widget = lookup_widget(window3, "button29");
1649 if(hd1) g_signal_handler_disconnect(G_OBJECT(widget), hd1);
1650 hd1 = g_signal_connect ( (gpointer) widget, "clicked",
1651 G_CALLBACK (on_button29_clicked),
1652 (gpointer) wp);
1653
1654 widget = lookup_widget(window3, "button21");
1655 if(hd2) g_signal_handler_disconnect(G_OBJECT(widget), hd2);
1656 hd2 = g_signal_connect ( (gpointer) widget, "clicked",
1657 G_CALLBACK (on_button21_clicked),
1658 (gpointer) g_strdup(photo_file));
1659
1660 }
1661
1662
1663 void
on_item11_activate(GtkMenuItem * menuitem,gpointer user_data)1664 on_item11_activate (GtkMenuItem *menuitem,
1665 gpointer user_data)
1666 {
1667
1668 }
1669
1670 void
on_button21_clicked(GtkButton * button,gpointer user_data)1671 on_button21_clicked (GtkButton *button,
1672 gpointer user_data)
1673 {
1674 GladeXML *gladexml;
1675 GtkWidget *widget;
1676 GtkWidget *drawingarea;
1677
1678 gchar buffer[512];
1679 gchar *photo_file = user_data;
1680
1681 GdkPixbuf *photo = NULL;
1682 GError *error = NULL;
1683 GdkGC *gc;
1684
1685 gladexml = glade_xml_new (gladefile, "win13_biggeo", GETTEXT_PACKAGE);
1686 glade_xml_signal_autoconnect (gladexml);
1687 widget = glade_xml_get_widget (gladexml, "win13_biggeo");
1688 g_signal_connect_swapped (widget, "destroy",
1689 G_CALLBACK (g_object_unref), gladexml);
1690
1691 gtk_widget_show(widget);
1692
1693 drawingarea = lookup_widget(widget, "drawingarea3");
1694
1695 photo = gdk_pixbuf_new_from_file_at_size (
1696 photo_file, 640,-1,
1697 &error);
1698 if(!photo)
1699 {
1700 printf ("+++++++++++++ FOTO NOT FOUND: %s +++++++++\n", photo_file);
1701 g_sprintf (buffer, _("File not found"));
1702 }
1703 else
1704 {
1705 gc = gdk_gc_new(pixmap_photo);
1706
1707 gdk_draw_rectangle (
1708 pixmap_photo,
1709 drawingarea->style->white_gc,
1710 TRUE,
1711 0, 0,
1712 drawingarea->allocation.width,
1713 drawingarea->allocation.height);
1714
1715 gdk_draw_pixbuf (
1716 pixmap_photo,
1717 gc,
1718 photo,
1719 0,0,
1720 0, 0,
1721 -1,-1,
1722 GDK_RGB_DITHER_NONE, 0, 0);
1723
1724 gdk_draw_drawable (
1725 drawingarea->window,
1726 drawingarea->style->fg_gc[GTK_WIDGET_STATE (drawingarea)],
1727 pixmap_photo,
1728 0,0,
1729 0,0,
1730 -1,-1);
1731
1732 gtk_widget_queue_draw_area (
1733 drawingarea,
1734 0, 0,
1735 80,80);
1736
1737 }
1738
1739
1740
1741
1742 gtk_widget_hide(window3);printf("*** %s(): 44\n",__PRETTY_FUNCTION__);
1743
1744 }
1745
1746
1747
1748 gboolean
on_item12_activate(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1749 on_item12_activate (GtkWidget *widget,
1750 GdkEventButton *event,
1751 gpointer user_data)
1752 {
1753 show_window6();
1754
1755 return FALSE;
1756 }
1757
1758
1759 gboolean
on_item14_activate(GtkWidget * widget,GdkEventButton * event,gpointer user_data)1760 on_item14_activate (GtkWidget *widget,
1761 GdkEventButton *event,
1762 gpointer user_data)
1763 {
1764 GtkWidget *dialog, *combobox;
1765
1766 dialog = glade_xml_get_widget (gladexml, "dialog6");
1767 gtk_widget_show(dialog);
1768
1769 combobox = lookup_widget(dialog, "combobox4");
1770 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
1771
1772 return FALSE;
1773 }
1774
1775
1776 void
on_cancelbutton4_clicked(GtkButton * button,gpointer user_data)1777 on_cancelbutton4_clicked (GtkButton *button,
1778 gpointer user_data)
1779 {
1780 GtkWidget *dialog;
1781
1782 dialog = lookup_widget(GTK_WIDGET(button), "window6");
1783 gtk_widget_destroy(dialog);
1784 }
1785
1786
1787 void
on_okbutton4_clicked(GtkButton * button,gpointer user_data)1788 on_okbutton4_clicked (GtkButton *button,
1789 gpointer user_data)
1790 {
1791 GtkWidget *dialog;
1792 dialog = lookup_widget(GTK_WIDGET(button), "window6");
1793 set_poi(dialog);
1794
1795
1796 global_show_pois = TRUE;
1797 repaint_all();
1798 }
1799
1800
1801 void
on_cancelbutton5_clicked(GtkButton * button,gpointer user_data)1802 on_cancelbutton5_clicked (GtkButton *button,
1803 gpointer user_data)
1804 {
1805 GtkWidget *dialog;
1806
1807 dialog = lookup_widget(GTK_WIDGET(button), "dialog6");
1808 gtk_widget_hide(dialog);
1809
1810 }
1811
1812
1813 void
on_okbutton5_clicked(GtkButton * button,gpointer user_data)1814 on_okbutton5_clicked (GtkButton *button,
1815 gpointer user_data)
1816 {
1817 GtkWidget *dialog,*combobox,*widget;
1818 gboolean pois_shown;
1819
1820 dialog = lookup_widget(GTK_WIDGET(button), "dialog6");
1821
1822 combobox = lookup_widget(GTK_WIDGET(button), "combobox4");
1823 global_poi_cat = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox));
1824
1825 gtk_widget_hide(dialog);
1826
1827 widget = lookup_widget(menu1, "item20");
1828 pois_shown = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
1829
1830 if(pois_shown)
1831 repaint_all();
1832 else
1833 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
1834
1835 }
1836
1837 gboolean
on_dialog6_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)1838 on_dialog6_delete_event (GtkWidget *widget,
1839 GdkEvent *event,
1840 gpointer user_data)
1841 {
1842 gtk_widget_hide (widget);
1843 return TRUE;
1844 }
1845
1846
1847 void
on_combobox2_changed(GtkComboBox * combobox,gpointer user_data)1848 on_combobox2_changed (GtkComboBox *combobox,
1849 gpointer user_data)
1850 {
1851 on_combobox_cat_changed(combobox);
1852 }
1853
1854 void
on_item15_activate(GtkMenuItem * menuitem,gpointer user_data)1855 on_item15_activate (GtkMenuItem *menuitem,
1856 gpointer user_data)
1857 {
1858 show_poi_detail();
1859 }
1860
1861 void
on_button22_clicked(GtkButton * button,gpointer user_data)1862 on_button22_clicked (GtkButton *button,
1863 gpointer user_data)
1864 {
1865 GtkWidget *window;
1866 window = lookup_widget(GTK_WIDGET(button), "window5");
1867 gtk_widget_destroy(window);
1868 }
1869
1870
1871
1872 void
on_entry16_changed(GtkEditable * editable,gpointer user_data)1873 on_entry16_changed (GtkEditable *editable,
1874 gpointer user_data)
1875 {
1876 gboolean success = FALSE;
1877
1878
1879 global_ffupdate_interval_minutes = atof(gtk_entry_get_text(GTK_ENTRY(editable)));
1880 global_ffupdate_interval = global_ffupdate_interval_minutes * 60000;
1881
1882 if (global_ffupdate_interval < 30000)
1883 global_ffupdate_interval = 30000;
1884
1885 if(global_fftimer_running)
1886 {
1887 if(friendfinder_timer) {
1888 g_source_remove(friendfinder_timer);
1889 friendfinder_timer = 0;
1890 }
1891
1892 if(msg_timer) {
1893 g_source_remove(msg_timer);
1894 msg_timer = 0;
1895 }
1896
1897 friendfinder_timer = g_timeout_add_seconds(global_ffupdate_interval/1000, update_position, NULL);
1898 msg_timer = g_timeout_add_seconds(global_ffupdate_interval/1000, send_message, NULL);
1899 }
1900
1901
1902 success = g_settings_set_double(
1903 global_settings,
1904 "ffupdate-interval-minutes",
1905 global_ffupdate_interval_minutes);
1906
1907 }
1908
1909
1910 void
on_radiobutton14_toggled(GtkToggleButton * togglebutton,gpointer user_data)1911 on_radiobutton14_toggled (GtkToggleButton *togglebutton,
1912 gpointer user_data)
1913 {
1914 gboolean success = FALSE;
1915
1916 global_speed_unit = (gtk_toggle_button_get_active(togglebutton)) ? 0 : global_speed_unit;
1917
1918 success = g_settings_set_int(
1919 global_settings,
1920 "speed-unit",
1921 global_speed_unit);
1922 }
1923
1924
1925 void
on_radiobutton15_toggled(GtkToggleButton * togglebutton,gpointer user_data)1926 on_radiobutton15_toggled (GtkToggleButton *togglebutton,
1927 gpointer user_data)
1928 {
1929 gboolean success = FALSE;
1930
1931 global_speed_unit = (gtk_toggle_button_get_active(togglebutton)) ? 1 : global_speed_unit;
1932
1933 success = g_settings_set_int(
1934 global_settings,
1935 "speed-unit",
1936 global_speed_unit);
1937 }
1938
1939
1940 void
on_radiobutton16_toggled(GtkToggleButton * togglebutton,gpointer user_data)1941 on_radiobutton16_toggled (GtkToggleButton *togglebutton,
1942 gpointer user_data)
1943 {
1944 gboolean success = FALSE;
1945
1946 global_speed_unit = (gtk_toggle_button_get_active(togglebutton)) ? 2 : global_speed_unit;
1947
1948 success = g_settings_set_int(
1949 global_settings,
1950 "speed-unit",
1951 global_speed_unit);
1952 }
1953
1954
1955 void
on_radiobutton17_toggled(GtkToggleButton * togglebutton,gpointer user_data)1956 on_radiobutton17_toggled (GtkToggleButton *togglebutton,
1957 gpointer user_data)
1958 {
1959 gboolean success = FALSE;
1960
1961 global_alt_unit = (gtk_toggle_button_get_active(togglebutton)) ? 0 : global_alt_unit;
1962
1963 success = g_settings_set_int(
1964 global_settings,
1965 "alt-unit",
1966 global_alt_unit);
1967 }
1968
1969
1970 void
on_radiobutton18_toggled(GtkToggleButton * togglebutton,gpointer user_data)1971 on_radiobutton18_toggled (GtkToggleButton *togglebutton,
1972 gpointer user_data)
1973 {
1974 gboolean success = FALSE;
1975
1976 global_alt_unit = (gtk_toggle_button_get_active(togglebutton)) ? 1 : global_alt_unit;
1977
1978 success = g_settings_set_int(
1979 global_settings,
1980 "alt-unit",
1981 global_alt_unit);
1982 }
1983
1984
1985 void
on_radiobutton19_toggled(GtkToggleButton * togglebutton,gpointer user_data)1986 on_radiobutton19_toggled (GtkToggleButton *togglebutton,
1987 gpointer user_data)
1988 {
1989 gboolean success = FALSE;
1990
1991 global_latlon_unit = (gtk_toggle_button_get_active(togglebutton)) ? 0 : global_latlon_unit;
1992
1993 success = g_settings_set_int(
1994 global_settings,
1995 "latlon-unit",
1996 global_latlon_unit);
1997 }
1998
1999
2000 void
on_radiobutton20_toggled(GtkToggleButton * togglebutton,gpointer user_data)2001 on_radiobutton20_toggled (GtkToggleButton *togglebutton,
2002 gpointer user_data)
2003 {
2004 gboolean success = FALSE;
2005
2006 global_latlon_unit = (gtk_toggle_button_get_active(togglebutton)) ? 1 : global_latlon_unit;
2007
2008 success = g_settings_set_int(
2009 global_settings,
2010 "latlon-unit",
2011 global_latlon_unit);
2012 }
2013
2014 void
on_radiobutton21_toggled(GtkToggleButton * togglebutton,gpointer user_data)2015 on_radiobutton21_toggled (GtkToggleButton *togglebutton,
2016 gpointer user_data)
2017 {
2018 gboolean success = FALSE;
2019
2020 global_latlon_unit = (gtk_toggle_button_get_active(togglebutton)) ? 2 : global_latlon_unit;
2021
2022 success = g_settings_set_int(
2023 global_settings,
2024 "latlon-unit",
2025 global_latlon_unit);
2026 }
2027
2028
2029 gboolean
on_button11_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)2030 on_button11_expose_event (GtkWidget *widget,
2031 GdkEventExpose *event,
2032 gpointer user_data)
2033 {
2034 return FALSE;
2035 }
2036
2037
2038
2039 void
on_button26_clicked(GtkButton * button,gpointer user_data)2040 on_button26_clicked (GtkButton *button,
2041 gpointer user_data)
2042 {
2043 GtkWidget *window;
2044 window = lookup_widget(GTK_WIDGET(button), "window8");
2045 gtk_widget_destroy(window);
2046 }
2047
2048 gboolean
on_window2_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)2049 on_window2_delete_event (GtkWidget *widget,
2050 GdkEvent *event,
2051 gpointer user_data)
2052 {
2053 gtk_widget_hide_on_delete (widget);
2054 distance_mode = FALSE;
2055 set_cursor(GDK_HAND2);
2056 repaint_all();
2057 return TRUE;
2058 }
2059
2060 void
on_button27_clicked(GtkButton * button,gpointer user_data)2061 on_button27_clicked (GtkButton *button,
2062 gpointer user_data)
2063 {
2064 GtkWidget *window;
2065 waypoint_t *wp;
2066
2067 wp = user_data;
2068 set_current_wp(wp->lat, wp->lon);
2069
2070 window = lookup_widget(GTK_WIDGET(button), "window5");
2071 gtk_widget_destroy(window);
2072 }
2073
2074
2075
2076 gboolean
on_window3_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)2077 on_window3_delete_event (GtkWidget *widget,
2078 GdkEvent *event,
2079 gpointer user_data)
2080 {
2081 gtk_widget_hide_on_delete (widget);
2082 return TRUE;
2083 }
2084
2085 void
on_item19_activate(GtkMenuItem * menuitem,gpointer user_data)2086 on_item19_activate (GtkMenuItem *menuitem,
2087 gpointer user_data)
2088 {
2089 gboolean active;
2090
2091 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem));
2092 global_show_friends = (active) ? TRUE : FALSE;
2093
2094
2095 if(global_show_friends && !global_fftimer_running) {
2096 GtkWidget *widget = NULL;
2097
2098 widget = lookup_widget(window1, "button11");
2099 gtk_button_clicked(GTK_BUTTON(widget));
2100 }
2101 repaint_all();
2102 }
2103
2104
2105 void
on_item20_activate(GtkMenuItem * menuitem,gpointer user_data)2106 on_item20_activate (GtkMenuItem *menuitem,
2107 gpointer user_data)
2108 {
2109 gboolean active;
2110
2111 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem));
2112 global_show_pois = (active) ? TRUE : FALSE;
2113
2114
2115
2116 repaint_all();
2117 }
2118
2119
2120
2121 void
on_item9_activate(GtkMenuItem * menuitem,gpointer user_data)2122 on_item9_activate (GtkMenuItem *menuitem,
2123 gpointer user_data)
2124 {
2125 gboolean active;
2126
2127 active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem));
2128 global_show_photos = (active) ? TRUE : FALSE;
2129
2130 if (active && photo_list == NULL)
2131 get_photos();
2132
2133 repaint_all();
2134 }
2135
2136
2137 void
repaint_all()2138 repaint_all()
2139 {
2140
2141
2142
2143 fill_tiles_pixel(global_x, global_y, global_zoom, FALSE);
2144 paint_track();
2145 paint_loaded_track();
2146 paint_friends();
2147 paint_photos();
2148 paint_pois();
2149 paint_wp();
2150 paint_route();
2151 paint_myposition();
2152
2153 }
2154
2155 void
on_button29_clicked(GtkButton * button,gpointer user_data)2156 on_button29_clicked (GtkButton *button,
2157 gpointer user_data)
2158 {
2159 GtkWidget *window;
2160 waypoint_t *wp;
2161
2162 wp = user_data;
2163 set_current_wp(wp->lat, wp->lon);
2164
2165 window = lookup_widget(GTK_WIDGET(button), "window3");
2166 gtk_widget_hide(window);
2167 }
2168
2169 void
on_button28_clicked(GtkButton * button,gpointer user_data)2170 on_button28_clicked (GtkButton *button,
2171 gpointer user_data)
2172 {
2173 GtkWidget *entry14, *entry15;
2174 char buf[64];
2175
2176 if(gpsdata && gpsdata->fix.latitude !=0)
2177 {
2178 entry14 = lookup_widget(GTK_WIDGET(button), "entry14");
2179 entry15 = lookup_widget(GTK_WIDGET(button), "entry15");
2180
2181 g_sprintf(buf, "%f", gpsdata->fix.latitude);
2182 gtk_entry_set_text(GTK_ENTRY(entry14), buf);
2183 g_sprintf(buf, "%f", gpsdata->fix.longitude);
2184 gtk_entry_set_text(GTK_ENTRY(entry15), buf);
2185 }
2186
2187 }
2188
2189 void
on_button33_clicked(GtkButton * button,gpointer user_data)2190 on_button33_clicked (GtkButton *button,
2191 gpointer user_data)
2192 {
2193 GladeXML *gladexml;
2194
2195 GtkWidget *widget;
2196 GtkTextBuffer *tbuffer;
2197 GtkWidget *window;
2198
2199 poi_t *p;
2200
2201 p = user_data;
2202 tbuffer = gtk_text_buffer_new(NULL);
2203 gtk_text_buffer_insert_at_cursor(tbuffer, "p->desc", -1);
2204 gtk_text_buffer_set_text(tbuffer, "p->desc", -1);
2205
2206
2207
2208
2209 gladexml = glade_xml_new (gladefile, "window10", GETTEXT_PACKAGE);
2210 glade_xml_signal_autoconnect (gladexml);
2211 window = glade_xml_get_widget (gladexml, "window10");
2212 g_signal_connect_swapped (window, "destroy",
2213 G_CALLBACK (g_object_unref), gladexml);
2214 gtk_widget_show(window);
2215
2216
2217
2218 widget = lookup_widget(window, "entry17");
2219 gtk_entry_set_text(GTK_ENTRY(widget), g_strdup_printf("%f",p->lat_deg));
2220
2221 widget = lookup_widget(window, "entry18");
2222 gtk_entry_set_text(GTK_ENTRY(widget), g_strdup_printf("%f",p->lon_deg));
2223
2224 widget = lookup_widget(window, "entry19");
2225 gtk_entry_set_text(GTK_ENTRY(widget), p->keywords);
2226
2227 widget = lookup_widget(window, "textview2");
2228 gtk_text_view_set_buffer(GTK_TEXT_VIEW(widget), tbuffer);
2229 gtk_text_buffer_set_text(tbuffer, p->desc, -1);
2230
2231 widget = lookup_widget(window, "label126");
2232
2233 if (p->idmd5==NULL)
2234 gtk_label_set_label (GTK_LABEL(widget),
2235 _("<span foreground='#ff0000'>"
2236 "POI has no ID -> see website for help!"
2237 "</span>"));
2238 else
2239 gtk_label_set_text(GTK_LABEL(widget), p->idmd5);
2240
2241
2242 widget = lookup_widget(GTK_WIDGET(button), "window5");
2243 gtk_widget_destroy(widget);
2244 }
2245
2246 void
on_cancelbutton5a_clicked(GtkButton * button,gpointer user_data)2247 on_cancelbutton5a_clicked (GtkButton *button,
2248 gpointer user_data)
2249 {
2250 GtkWidget *dialog;
2251
2252 dialog = lookup_widget(GTK_WIDGET(button), "window10");
2253 gtk_widget_destroy(dialog);
2254 }
2255
2256
2257
2258 void
on_okbutton5a_clicked(GtkButton * button,gpointer user_data)2259 on_okbutton5a_clicked (GtkButton *button,
2260 gpointer user_data)
2261 {
2262 GtkWidget *widget;
2263 widget = lookup_widget(GTK_WIDGET(button), "window10");
2264 update_poi(widget);
2265
2266
2267
2268
2269 repaint_all();
2270 }
2271
2272 void
on_button30_clicked(GtkButton * button,gpointer user_data)2273 on_button30_clicked (GtkButton *button,
2274 gpointer user_data)
2275 {
2276 GtkWidget *entry17, *entry18;
2277 char buf[64];
2278
2279 if(gpsdata && gpsdata->fix.latitude !=0)
2280 {
2281 entry17 = lookup_widget(GTK_WIDGET(button), "entry17");
2282 entry18 = lookup_widget(GTK_WIDGET(button), "entry18");
2283
2284 g_sprintf(buf, "%f", gpsdata->fix.latitude);
2285 gtk_entry_set_text(GTK_ENTRY(entry17), buf);
2286 g_sprintf(buf, "%f", gpsdata->fix.longitude);
2287 gtk_entry_set_text(GTK_ENTRY(entry18), buf);
2288 }
2289
2290 }
2291
2292 gboolean
on_drawingarea1_key_press_event(GtkWidget * widget,GdkEventKey * event,gpointer user_data)2293 on_drawingarea1_key_press_event (GtkWidget *widget,
2294 GdkEventKey *event,
2295 gpointer user_data)
2296 {
2297 if (event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Up || event->keyval == GDK_i)
2298 on_button4_clicked(NULL, NULL);
2299 else if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK && event->keyval == GDK_p)
2300 geo_photos_open_dialog_photo_correlate();
2301 else if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK && event->keyval == GDK_t)
2302 tracks_open_tracks_dialog();
2303 else if(event->keyval == GDK_Page_Down || event->keyval == GDK_o)
2304 on_button5_clicked(NULL, NULL);
2305 else if(event->keyval == GDK_m)
2306 on_button76_clicked(NULL, NULL);
2307 else if(event->keyval == GDK_space || event->keyval == GDK_F11)
2308 {
2309 maximized = !maximized;
2310 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1, "button1")), maximized);
2311 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1, "button53")), maximized);
2312 }
2313 else if(event->keyval == GDK_Right)
2314 move_map(1);
2315 else if(event->keyval == GDK_Down)
2316 move_map(2);
2317 else if(event->keyval == GDK_Left)
2318 move_map(3);
2319 else if(event->keyval == GDK_Up)
2320 move_map(4);
2321 else if(event->keyval == GDK_a)
2322 {
2323 global_autocenter = !global_autocenter;
2324 GtkToggleToolButton *autocenter_toggle;
2325
2326 autocenter_toggle =
2327 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1,
2328 "button3"));
2329 gtk_toggle_tool_button_set_active(autocenter_toggle,
2330 global_autocenter);
2331
2332 autocenter_toggle =
2333 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1,
2334 "button56"));
2335 gtk_toggle_tool_button_set_active(autocenter_toggle,
2336 global_autocenter);
2337 }
2338 else if(event->keyval == GDK_r)
2339 on_item23_button_release_event(NULL, NULL, NULL);
2340 else if(event->keyval == GDK_1)
2341 {
2342 GtkWidget *widget;
2343 widget = lookup_widget(window1, "combobox1");
2344 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 0);
2345 repaint_all();
2346 }
2347 else if(event->keyval == GDK_2)
2348 {
2349 GtkWidget *widget;
2350 widget = lookup_widget(window1, "combobox1");
2351 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 1);
2352 repaint_all();
2353 }
2354 else if(event->keyval == GDK_3)
2355 {
2356 GtkWidget *widget;
2357 widget = lookup_widget(window1, "combobox1");
2358 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 2);
2359 repaint_all();
2360 }
2361 else if(event->keyval == GDK_4)
2362 {
2363 GtkWidget *widget;
2364 widget = lookup_widget(window1, "combobox1");
2365 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 3);
2366 repaint_all();
2367 }
2368 else if(event->keyval == GDK_5)
2369 {
2370 GtkWidget *widget;
2371 widget = lookup_widget(window1, "combobox1");
2372 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 4);
2373 repaint_all();
2374 }
2375 else if(event->keyval == GDK_6)
2376 {
2377 GtkWidget *widget;
2378 widget = lookup_widget(window1, "combobox1");
2379 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 5);
2380 repaint_all();
2381 }
2382 else if(event->keyval == GDK_7)
2383 {
2384 GtkWidget *widget;
2385 widget = lookup_widget(window1, "combobox1");
2386 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 6);
2387 repaint_all();
2388 }
2389 else if(event->keyval == GDK_8)
2390 {
2391 GtkWidget *widget;
2392 widget = lookup_widget(window1, "combobox1");
2393 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 7);
2394 repaint_all();
2395 }
2396
2397 return TRUE;
2398 }
2399
2400 void
on_button34_clicked(GtkButton * button,gpointer user_data)2401 on_button34_clicked (GtkButton *button,
2402 gpointer user_data)
2403 {
2404 GladeXML *gladexml;
2405 GtkWidget *widget, *widget2;
2406 poi_t *p;
2407
2408 p = user_data;
2409 gladexml = glade_xml_new (gladefile,
2410 "dialog7",
2411 GETTEXT_PACKAGE);
2412 glade_xml_signal_autoconnect (gladexml);
2413 widget = glade_xml_get_widget (gladexml, "dialog7");
2414 g_signal_connect_swapped (widget, "destroy",
2415 G_CALLBACK (g_object_unref), gladexml);
2416 gtk_widget_show(widget);
2417
2418 widget2 = lookup_widget(widget, "okbutton6");
2419 g_signal_connect ( (gpointer) widget2, "clicked",
2420 G_CALLBACK (on_okbutton6_clicked),
2421 (gpointer) p);
2422 }
2423
2424
2425 gboolean
on_dialog7_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)2426 on_dialog7_delete_event (GtkWidget *widget,
2427 GdkEvent *event,
2428 gpointer user_data)
2429 {
2430 return FALSE;
2431 }
2432
2433
2434 void
on_cancelbutton6_clicked(GtkButton * button,gpointer user_data)2435 on_cancelbutton6_clicked (GtkButton *button,
2436 gpointer user_data)
2437 {
2438 GtkWidget *widget;
2439
2440 widget = lookup_widget(GTK_WIDGET(button), "dialog7");
2441 gtk_widget_destroy(widget);
2442 }
2443
2444
2445 void
on_okbutton6_clicked(GtkButton * button,gpointer user_data)2446 on_okbutton6_clicked (GtkButton *button,
2447 gpointer user_data)
2448 {
2449 GtkWidget *widget;
2450 poi_t *p;
2451
2452 p = user_data;
2453
2454 gtk_widget_destroy(p->widget);
2455 delete_poi(p);
2456
2457 widget = lookup_widget(GTK_WIDGET(button), "dialog7");
2458 gtk_widget_destroy(widget);
2459 }
2460
2461 void
on_button35_clicked(GtkButton * button,gpointer user_data)2462 on_button35_clicked (GtkButton *button,
2463 gpointer user_data)
2464 {
2465 GtkWidget *widget;
2466 widget = lookup_widget(window1, "vbox48");
2467
2468 if(msg_pane_visible)
2469 {
2470 gtk_widget_hide(widget);
2471 msg_pane_visible = FALSE;
2472 gtk_button_set_label (button, _("Show Messages"));
2473 }
2474 else
2475 {
2476 gtk_widget_show(widget);
2477 msg_pane_visible = TRUE;
2478 gtk_button_set_label (button, _("Hide Messages"));
2479 }
2480 }
2481
2482 void
on_entry3_changed(GtkEditable * editable,gpointer user_data)2483 on_entry3_changed (GtkEditable *editable,
2484 gpointer user_data)
2485 {
2486 GtkWidget *widget;
2487 const char *entry;
2488
2489 widget = lookup_widget(window1, "entry3");
2490 entry = gtk_entry_get_text(GTK_ENTRY(widget));
2491
2492 g_settings_set_string( global_settings,
2493 "gpsd-host",
2494 entry);
2495 }
2496
2497
2498 void
on_entry4_changed(GtkEditable * editable,gpointer user_data)2499 on_entry4_changed (GtkEditable *editable,
2500 gpointer user_data)
2501 {
2502 GtkWidget *widget;
2503 const char *entry;
2504
2505 widget = lookup_widget(window1, "entry4");
2506 entry = gtk_entry_get_text(GTK_ENTRY(widget));
2507
2508 g_settings_set_string( global_settings,
2509 "gpsd-port",
2510 entry);
2511 }
2512
2513 void
on_button36_clicked(GtkButton * button,gpointer user_data)2514 on_button36_clicked (GtkButton *button,
2515 gpointer user_data)
2516 {
2517 tracks_open_tracks_dialog();
2518 }
2519
2520 gboolean
on_window12_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)2521 on_window12_delete_event (GtkWidget *widget,
2522 GdkEvent *event,
2523 gpointer user_data)
2524 {
2525 GtkWidget *window, *vbox;
2526
2527 window = lookup_widget(widget, "window12");
2528 gtk_widget_hide(window);
2529
2530 vbox = lookup_widget(window, "vbox39");
2531 gtk_container_foreach (GTK_CONTAINER (vbox),
2532 (GtkCallback) gtk_widget_destroy,
2533 NULL);
2534
2535 return TRUE;
2536 }
2537
2538 void
on_button37_clicked(GtkButton * button,gpointer user_data)2539 on_button37_clicked (GtkButton *button,
2540 gpointer user_data)
2541 {
2542 GtkWidget *widget, *vbox;
2543
2544 widget = lookup_widget(GTK_WIDGET(button), "window12");
2545 gtk_widget_hide(widget);
2546
2547 vbox = lookup_widget(widget, "vbox39");
2548 gtk_container_foreach (GTK_CONTAINER (vbox),
2549 (GtkCallback) gtk_widget_destroy,
2550 NULL);
2551 }
2552
2553 void
on_button38_clicked(GtkButton * button,gpointer user_data)2554 on_button38_clicked (GtkButton *button,
2555 gpointer user_data)
2556 {
2557 GtkWidget *entry_repo;
2558 GtkWidget *entry_uri;
2559 GtkWidget *entry_dir;
2560 GtkWidget *togglebutton;
2561 repo_t *repo;
2562
2563 dialog8 = glade_xml_get_widget (gladexml, "dialog8");
2564
2565 entry_repo = lookup_widget(dialog8, "entry24");
2566 entry_uri = lookup_widget(dialog8, "entry25");
2567 entry_dir = lookup_widget(dialog8, "entry26");
2568 togglebutton = lookup_widget(dialog8, "checkbutton13");
2569
2570 repo = global_curr_repo->data;
2571 gtk_entry_set_text( GTK_ENTRY(entry_repo), repo->name );
2572 gtk_entry_set_text( GTK_ENTRY(entry_uri), repo->uri );
2573 gtk_entry_set_text( GTK_ENTRY(entry_dir), repo->dir );
2574 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(togglebutton), repo->inverted_zoom);
2575
2576
2577
2578 gtk_widget_show(dialog8);
2579 }
2580
2581
2582 void
on_cancelbutton7_clicked(GtkButton * button,gpointer user_data)2583 on_cancelbutton7_clicked (GtkButton *button,
2584 gpointer user_data)
2585 {
2586 GtkWidget *widget;
2587
2588 widget = lookup_widget(GTK_WIDGET(button), "dialog8");
2589
2590 gtk_widget_hide(dialog8);
2591 }
2592
2593
2594 void
on_okbutton7_clicked(GtkButton * button,gpointer user_data)2595 on_okbutton7_clicked (GtkButton *button,
2596 gpointer user_data)
2597 {
2598 GtkWidget *entry_repo;
2599 GtkComboBox *combobox;
2600 GtkWidget *entry_uri;
2601 GtkWidget *entry_dir;
2602 GtkWidget *togglebutton;
2603 const gchar *reponame, *uri, *dir;
2604 gboolean reversed;
2605 repo_t *repo;
2606
2607 repo = global_curr_repo->data;
2608
2609 entry_repo = lookup_widget(dialog8, "entry24");
2610 entry_uri = lookup_widget(dialog8, "entry25");
2611 entry_dir = lookup_widget(dialog8, "entry26");
2612 togglebutton = lookup_widget(dialog8, "checkbutton13");
2613 combobox = GTK_COMBO_BOX(lookup_widget(window1, "combobox1"));
2614
2615 reponame = gtk_entry_get_text(GTK_ENTRY(entry_repo));
2616 uri = gtk_entry_get_text(GTK_ENTRY(entry_uri));
2617 dir = gtk_entry_get_text(GTK_ENTRY(entry_dir));
2618 reversed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton));
2619
2620 repo->name = g_strdup(reponame);
2621 repo->dir = g_strdup(dir);
2622 repo->uri = g_strdup(uri);
2623 repo->inverted_zoom = reversed;
2624
2625 global_curr_reponame = g_strdup(reponame);
2626
2627 gtk_combo_box_remove_text(combobox, gtk_combo_box_get_active(combobox));
2628 gtk_combo_box_prepend_text (combobox, g_strdup(repo->name));
2629 gtk_combo_box_set_active(combobox, 0);
2630
2631 settings_set_repolist();
2632
2633 gtk_widget_hide(dialog8);
2634
2635 }
2636
2637 void
on_entry5_changed(GtkEditable * editable,gpointer user_data)2638 on_entry5_changed (GtkEditable *editable,
2639 gpointer user_data)
2640 {
2641 GtkWidget *widget;
2642 const char *txt1, *txt2, *txt3;
2643
2644
2645 widget = lookup_widget(GTK_WIDGET(editable), "entry5");
2646 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2647 widget = lookup_widget(GTK_WIDGET(editable), "entry20");
2648 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2649 widget = lookup_widget(GTK_WIDGET(editable), "entry21");
2650 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2651
2652
2653 widget = lookup_widget(GTK_WIDGET(editable), "okbutton1");
2654
2655 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2656 gtk_widget_set_sensitive (widget, TRUE);
2657 else
2658 gtk_widget_set_sensitive (widget, FALSE);
2659
2660 }
2661
2662
2663 void
on_entry20_changed(GtkEditable * editable,gpointer user_data)2664 on_entry20_changed (GtkEditable *editable,
2665 gpointer user_data)
2666 {
2667 GtkWidget *widget;
2668 const char *txt1, *txt2, *txt3;
2669
2670
2671 widget = lookup_widget(GTK_WIDGET(editable), "entry5");
2672 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2673 widget = lookup_widget(GTK_WIDGET(editable), "entry20");
2674 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2675 widget = lookup_widget(GTK_WIDGET(editable), "entry21");
2676 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2677
2678
2679 widget = lookup_widget(GTK_WIDGET(editable), "okbutton1");
2680
2681 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2682 gtk_widget_set_sensitive (widget, TRUE);
2683 else
2684 gtk_widget_set_sensitive (widget, FALSE);
2685
2686 }
2687
2688
2689 void
on_entry21_changed(GtkEditable * editable,gpointer user_data)2690 on_entry21_changed (GtkEditable *editable,
2691 gpointer user_data)
2692 {
2693 GtkWidget *widget;
2694 const char *txt1, *txt2, *txt3;
2695 const gchar *dir;
2696 int result;
2697
2698 dir = gtk_entry_get_text(GTK_ENTRY(editable));
2699
2700 result = strncmp(dir, "~", 1);
2701 if(!result)
2702 gtk_entry_set_text(GTK_ENTRY(editable), g_strdup(getenv("HOME")));
2703
2704
2705
2706 widget = lookup_widget(GTK_WIDGET(editable), "entry5");
2707 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2708 widget = lookup_widget(GTK_WIDGET(editable), "entry20");
2709 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2710 widget = lookup_widget(GTK_WIDGET(editable), "entry21");
2711 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2712
2713 widget = lookup_widget(GTK_WIDGET(editable), "okbutton1");
2714
2715 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2716 gtk_widget_set_sensitive (widget, TRUE);
2717 else
2718 gtk_widget_set_sensitive (widget, FALSE);
2719
2720 }
2721
2722
2723 void
on_checkbutton12_toggled(GtkToggleButton * togglebutton,gpointer user_data)2724 on_checkbutton12_toggled (GtkToggleButton *togglebutton,
2725 gpointer user_data)
2726 {
2727
2728 }
2729
2730
2731 void
on_entry24_changed(GtkEditable * editable,gpointer user_data)2732 on_entry24_changed (GtkEditable *editable,
2733 gpointer user_data)
2734 {
2735 GtkWidget *widget;
2736 const char *txt1, *txt2, *txt3;
2737
2738
2739 widget = lookup_widget(GTK_WIDGET(editable), "entry24");
2740 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2741 widget = lookup_widget(GTK_WIDGET(editable), "entry25");
2742 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2743 widget = lookup_widget(GTK_WIDGET(editable), "entry26");
2744 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2745
2746
2747 widget = lookup_widget(GTK_WIDGET(editable), "okbutton7");
2748
2749 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2750 gtk_widget_set_sensitive (widget, TRUE);
2751 else
2752 gtk_widget_set_sensitive (widget, FALSE);
2753
2754 }
2755
2756
2757 void
on_entry25_changed(GtkEditable * editable,gpointer user_data)2758 on_entry25_changed (GtkEditable *editable,
2759 gpointer user_data)
2760 {
2761 GtkWidget *widget;
2762 const char *txt1, *txt2, *txt3;
2763
2764
2765 widget = lookup_widget(GTK_WIDGET(editable), "entry24");
2766 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2767 widget = lookup_widget(GTK_WIDGET(editable), "entry25");
2768 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2769 widget = lookup_widget(GTK_WIDGET(editable), "entry26");
2770 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2771
2772
2773 widget = lookup_widget(GTK_WIDGET(editable), "okbutton7");
2774
2775 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2776 gtk_widget_set_sensitive (widget, TRUE);
2777 else
2778 gtk_widget_set_sensitive (widget, FALSE);
2779
2780 }
2781
2782
2783 void
on_entry26_changed(GtkEditable * editable,gpointer user_data)2784 on_entry26_changed (GtkEditable *editable,
2785 gpointer user_data)
2786 {
2787 GtkWidget *widget;
2788 const char *txt1, *txt2, *txt3;
2789 const gchar *dir;
2790 int result;
2791
2792 dir = gtk_entry_get_text(GTK_ENTRY(editable));
2793
2794 result = strncmp(dir, "~", 1);
2795 if(!result)
2796 gtk_entry_set_text(GTK_ENTRY(editable), g_strdup(getenv("HOME")));
2797
2798
2799
2800 widget = lookup_widget(GTK_WIDGET(editable), "entry24");
2801 txt1 = gtk_entry_get_text(GTK_ENTRY(widget));
2802 widget = lookup_widget(GTK_WIDGET(editable), "entry25");
2803 txt2 = gtk_entry_get_text(GTK_ENTRY(widget));
2804 widget = lookup_widget(GTK_WIDGET(editable), "entry26");
2805 txt3 = gtk_entry_get_text(GTK_ENTRY(widget));
2806
2807 widget = lookup_widget(GTK_WIDGET(editable), "okbutton7");
2808
2809 if(strlen(txt1) && strlen(txt2) && strlen(txt3))
2810 gtk_widget_set_sensitive (widget, TRUE);
2811 else
2812 gtk_widget_set_sensitive (widget, FALSE);
2813
2814 }
2815
2816
2817 void
on_checkbutton13_toggled(GtkToggleButton * togglebutton,gpointer user_data)2818 on_checkbutton13_toggled (GtkToggleButton *togglebutton,
2819 gpointer user_data)
2820 {
2821
2822 }
2823
2824 void
on_entry21_activate(GtkEntry * entry,gpointer user_data)2825 on_entry21_activate (GtkEntry *entry,
2826 gpointer user_data)
2827 {
2828 }
2829
2830 gboolean
on_eventbox1_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)2831 on_eventbox1_button_release_event (GtkWidget *widget,
2832 GdkEventButton *event,
2833 gpointer user_data)
2834 {
2835 GtkWidget *window;
2836
2837 window = lookup_widget(widget, "drawingarea2");
2838
2839
2840
2841 gdk_draw_rectangle (
2842 pixmap_photo,
2843 widget->style->white_gc,
2844 TRUE,
2845 0, 0,
2846 widget->allocation.width,
2847 widget->allocation.height);
2848
2849 gtk_widget_queue_draw_area (
2850 widget,
2851 0,0,widget->allocation.width,widget->allocation.height);
2852
2853 gtk_widget_hide(window3);
2854
2855 return FALSE;
2856 }
2857
2858 gboolean
on_eventbox2_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)2859 on_eventbox2_button_release_event (GtkWidget *widget,
2860 GdkEventButton *event,
2861 gpointer user_data)
2862 {
2863 GtkWidget *window;
2864
2865 window = lookup_widget(widget, "win13_biggeo");
2866
2867 gtk_widget_destroy(window);
2868
2869 return FALSE;
2870 }
2871
2872 gboolean
on_drawingarea3_configure_event(GtkWidget * widget,GdkEventConfigure * event,gpointer user_data)2873 on_drawingarea3_configure_event (GtkWidget *widget,
2874 GdkEventConfigure *event,
2875 gpointer user_data)
2876 {
2877 if (!pixmap_photo_big)
2878 pixmap_photo = gdk_pixmap_new (
2879 widget->window,
2880 widget->allocation.width,
2881 widget->allocation.height,
2882 -1);
2883
2884 if (!pixmap_photo_big)
2885 {
2886 printf("aieee: pixmap_photo NULL\n");
2887 }
2888
2889 return FALSE;
2890 }
2891
2892
2893 gboolean
on_drawingarea3_expose_event(GtkWidget * widget,GdkEventExpose * event,gpointer user_data)2894 on_drawingarea3_expose_event (GtkWidget *widget,
2895 GdkEventExpose *event,
2896 gpointer user_data)
2897 {
2898 gdk_draw_drawable (
2899 widget->window,
2900 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
2901 pixmap_photo,
2902 event->area.x, event->area.y,
2903 event->area.x, event->area.y,
2904 event->area.width, event->area.height);
2905
2906
2907 return FALSE;
2908 }
2909
2910 gboolean
on_itemgeocode1_activate(GtkWidget * widget,GdkEventButton * event,gpointer user_data)2911 on_itemgeocode1_activate (GtkWidget *widget,
2912 GdkEventButton *event,
2913 gpointer user_data)
2914 {
2915 geo_photos_open_dialog_photo_correlate();
2916 return FALSE;
2917 }
2918
2919 gboolean
on_itemgeocode1_expose_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)2920 on_itemgeocode1_expose_event (GtkWidget *widget, GdkEvent *event, gpointer user_data)
2921 {
2922 if (system ("command -v gpscorrelate > /dev/null") != 0) {
2923 gtk_widget_set_sensitive (widget, FALSE);
2924 gtk_widget_set_tooltip_text
2925 (widget, _("gpscorrelate is necessary for this feature "
2926 "but does not appear to be installed."));
2927 } else {
2928 gtk_widget_set_sensitive (widget, TRUE);
2929 gtk_widget_set_tooltip_text (widget, NULL);
2930 }
2931
2932 return FALSE;
2933 }
2934
2935
2936
2937 void
on_button39_clicked(GtkButton * button,gpointer user_data)2938 on_button39_clicked (GtkButton *button,
2939 gpointer user_data)
2940 {
2941 geo_photos_geocode_track_select_dialog(button, user_data);
2942 }
2943
2944
2945 void
on_button40_clicked(GtkButton * button,gpointer user_data)2946 on_button40_clicked (GtkButton *button,
2947 gpointer user_data)
2948 {
2949 geo_photos_geocode_dir_select_dialog(button, user_data);
2950 }
2951
2952
2953 void
on_cancelbutton8_clicked(GtkButton * button,gpointer user_data)2954 on_cancelbutton8_clicked (GtkButton *button,
2955 gpointer user_data)
2956 {
2957 geo_photo_cancel_dialog_photo_correlate();
2958 }
2959
2960
2961 void
on_okbutton8_clicked(GtkButton * button,gpointer user_data)2962 on_okbutton8_clicked (GtkButton *button,
2963 gpointer user_data)
2964 {
2965 geo_photo_close_dialog_photo_correlate();
2966 }
2967
2968 void
on_button44_clicked(GtkButton * button,gpointer user_data)2969 on_button44_clicked (GtkButton *button,
2970 gpointer user_data)
2971 {
2972 geo_photos_open_dialog_image_data();
2973 }
2974
2975
2976 void
on_button45_clicked(GtkButton * button,gpointer user_data)2977 on_button45_clicked (GtkButton *button,
2978 gpointer user_data)
2979 {
2980 GtkWidget *widget = lookup_widget(GTK_WIDGET(button), "dialog_image_data");
2981 geo_photo_dialog_image_data_next(widget, user_data, GEOPHOTO_PREV);
2982 }
2983
2984
2985 void
on_button46_clicked(GtkButton * button,gpointer user_data)2986 on_button46_clicked (GtkButton *button,
2987 gpointer user_data)
2988 {
2989 GtkWidget *widget = lookup_widget(GTK_WIDGET(button), "dialog_image_data");
2990 geo_photo_dialog_image_data_next(widget, user_data, GEOPHOTO_NEXT);
2991 }
2992
2993 void
on_button47_clicked(GtkButton * button,gpointer user_data)2994 on_button47_clicked (GtkButton *button,
2995 gpointer user_data)
2996 {
2997 GtkWidget *widget = lookup_widget(GTK_WIDGET(button), "dialog_image_data");
2998 geo_photo_dialog_image_data_next(widget, user_data, GEOPHOTO_FIRST);
2999 }
3000
3001
3002 void
on_button48_clicked(GtkButton * button,gpointer user_data)3003 on_button48_clicked (GtkButton *button,
3004 gpointer user_data)
3005 {
3006 GtkWidget *widget = lookup_widget(GTK_WIDGET(button), "dialog_image_data");
3007 geo_photo_dialog_image_data_next(widget, user_data, GEOPHOTO_LAST);
3008 }
3009
3010 void
on_okbutton9_clicked(GtkButton * button,gpointer user_data)3011 on_okbutton9_clicked (GtkButton *button,
3012 gpointer user_data)
3013 {
3014 geo_photo_close_dialog_image_data();
3015 }
3016
3017
3018 void
on_button49_clicked(GtkButton * button,gpointer user_data)3019 on_button49_clicked (GtkButton *button,
3020 gpointer user_data)
3021 {
3022 geo_photo_cancel_dialog_image_data();
3023 }
3024
3025
3026 gboolean
on_eventbox3_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3027 on_eventbox3_button_release_event (GtkWidget *widget,
3028 GdkEventButton *event,
3029 gpointer user_data)
3030 {
3031
3032
3033 return FALSE;
3034 }
3035
3036 int
on_checkbutton14_expose_event(GtkWidget * togglebutton,gpointer user_data)3037 on_checkbutton14_expose_event (GtkWidget *togglebutton, gpointer user_data)
3038 {
3039 if (system ("command -v jhead > /dev/null") != 0) {
3040 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), FALSE);
3041 gtk_widget_set_sensitive (togglebutton, FALSE);
3042 gtk_widget_set_tooltip_text
3043 (togglebutton, _("jhead is necessary for this feature "
3044 "but does not appear to be installed."));
3045 } else {
3046 gtk_widget_set_sensitive (togglebutton, TRUE);
3047 gtk_widget_set_tooltip_text (togglebutton, NULL);
3048 }
3049
3050 return FALSE;
3051 }
3052
3053 void
on_checkbutton14_toggled(GtkToggleButton * togglebutton,gpointer user_data)3054 on_checkbutton14_toggled (GtkToggleButton *togglebutton,
3055 gpointer user_data)
3056 {
3057 geo_photo_set_add_to_database(togglebutton);
3058 }
3059
3060
3061 void
on_combobox7_changed(GtkComboBox * combobox,gpointer user_data)3062 on_combobox7_changed (GtkComboBox *combobox,
3063 gpointer user_data)
3064 {
3065 geo_photo_set_timezone(combobox);
3066 }
3067
3068
3069 gboolean
on_dialog_geocode_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)3070 on_dialog_geocode_delete_event (GtkWidget *widget,
3071 GdkEvent *event,
3072 gpointer user_data)
3073 {
3074 geo_photo_cancel_dialog_photo_correlate();
3075 return TRUE;
3076 }
3077
3078
3079 gboolean
on_dialog_image_data_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)3080 on_dialog_image_data_delete_event (GtkWidget *widget,
3081 GdkEvent *event,
3082 gpointer user_data)
3083 {
3084 geo_photo_close_dialog_image_data();
3085
3086 return TRUE;
3087 }
3088
3089 gboolean
on_eventbox4_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3090 on_eventbox4_button_release_event (GtkWidget *widget,
3091 GdkEventButton *event,
3092 gpointer user_data)
3093 {
3094 GtkWidget *window;
3095 window = lookup_widget(widget, "window2");
3096 gtk_widget_hide(window);
3097 distance_mode = FALSE;
3098 set_cursor(GDK_HAND2);
3099 repaint_all();
3100
3101 return FALSE;
3102 }
3103
3104 void
on_entry28_changed(GtkEditable * editable,gpointer user_data)3105 on_entry28_changed (GtkEditable *editable,
3106 gpointer user_data)
3107 {
3108 geo_photo_correction_entry_cb(editable);
3109 }
3110
3111
3112 void
on_button50_clicked(GtkButton * button,gpointer user_data)3113 on_button50_clicked (GtkButton *button,
3114 gpointer user_data)
3115 {
3116 GtkWidget *window = lookup_widget(GTK_WIDGET(button), "dialog_image_data");
3117 geo_photo_dialog_image_data_next(window, user_data, GEOPHOTO_FULLSIZE);
3118 gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
3119 }
3120
3121 void
on_closebutton2_clicked(GtkButton * button,gpointer user_data)3122 on_closebutton2_clicked (GtkButton *button,
3123 gpointer user_data)
3124 {
3125 GtkWidget *widget = lookup_widget(GTK_WIDGET(button), "dialog_geocode_result");
3126 gtk_widget_hide(widget);
3127 }
3128
3129 void
on_radiobutton27_toggled(GtkToggleButton * togglebutton,gpointer user_data)3130 on_radiobutton27_toggled (GtkToggleButton *togglebutton,
3131 gpointer user_data)
3132 {
3133 global_ff_mode = FUN_MODE;
3134 }
3135
3136
3137 void
on_radiobutton28_toggled(GtkToggleButton * togglebutton,gpointer user_data)3138 on_radiobutton28_toggled (GtkToggleButton *togglebutton,
3139 gpointer user_data)
3140 {
3141 global_ff_mode = FRIEND_MODE;
3142 }
3143
3144
3145 void
on_radiobutton29_toggled(GtkToggleButton * togglebutton,gpointer user_data)3146 on_radiobutton29_toggled (GtkToggleButton *togglebutton,
3147 gpointer user_data)
3148 {
3149 global_ff_mode = PRIVATE_MODE;
3150 }
3151
3152
3153 void
on_button51_clicked(GtkButton * button,gpointer user_data)3154 on_button51_clicked (GtkButton *button,
3155 gpointer user_data)
3156 {
3157 set_cursor(GDK_CROSSHAIR);
3158
3159 distance_mode = TRUE;
3160 }
3161
3162
3163 void
on_button52_clicked(GtkButton * button,gpointer user_data)3164 on_button52_clicked (GtkButton *button,
3165 gpointer user_data)
3166 {
3167
3168 }
3169
3170 void
do_distance()3171 do_distance()
3172 {
3173 on_item4_activate(NULL, NULL);
3174 }
3175
3176 gboolean
on_item17_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3177 on_item17_button_release_event (GtkWidget *widget,
3178 GdkEventButton *event,
3179 gpointer user_data)
3180 {
3181 float lat, lon;
3182
3183 lat = pixel2lat(global_zoom, global_y+mouse_y);
3184 lon = pixel2lon(global_zoom, global_x+mouse_x);
3185
3186 set_current_wp(lat, lon);
3187 return FALSE;
3188 }
3189
3190 gboolean
on_add_wp_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3191 on_add_wp_button_release_event (GtkWidget *widget,
3192 GdkEventButton *event,
3193 gpointer user_data)
3194 {
3195 float lat, lon;
3196
3197 lat = pixel2lat (global_zoom, global_y+mouse_y);
3198 lon = pixel2lon (global_zoom, global_x+mouse_x);
3199
3200 append_waypoint_to_route (lat, lon);
3201 repaint_all ();
3202
3203 return FALSE;
3204 }
3205
3206 gboolean
on_clear_route_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3207 on_clear_route_button_release_event (GtkWidget *widget,
3208 GdkEventButton *event,
3209 gpointer user_data)
3210 {
3211 reset_route ();
3212 repaint_all ();
3213 return FALSE;
3214 }
3215
3216 gboolean
on_save_route_gpx_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3217 on_save_route_gpx_button_release_event (GtkWidget *widget,
3218 GdkEventButton *event,
3219 gpointer user_data)
3220 {
3221 char *filename;
3222
3223 filename = choose_save_file ("Unnamed.gpx");
3224 save_route_as_gpx (filename);
3225 g_free (filename);
3226 return FALSE;
3227 }
3228
3229 gboolean
on_load_route_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3230 on_load_route_button_release_event (GtkWidget *widget,
3231 GdkEventButton *event,
3232 gpointer user_data)
3233 {
3234 char *filename;
3235
3236 filename = choose_load_file ();
3237 load_route (filename);
3238 repaint_all ();
3239 g_free (filename);
3240 return FALSE;
3241 }
3242
3243 gboolean
on_save_route_tomtom_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3244 on_save_route_tomtom_button_release_event (GtkWidget *widget,
3245 GdkEventButton *event,
3246 gpointer user_data)
3247 {
3248 char *filename;
3249
3250 filename = choose_save_file ("Unnamed.itn");
3251 save_route_as_tomtom_itn (filename);
3252 g_free (filename);
3253 return FALSE;
3254 }
3255
3256
3257 gboolean
on_item18_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3258 on_item18_button_release_event (GtkWidget *widget,
3259 GdkEventButton *event,
3260 gpointer user_data)
3261 {
3262 global_wp_on = FALSE;
3263 repaint_all();
3264 return FALSE;
3265 }
3266
3267
3268
3269
3270 void
on_button57_clicked(GtkButton * button,gpointer user_data)3271 on_button57_clicked (GtkButton *button,
3272 gpointer user_data)
3273 {
3274 GtkWidget *combobox;
3275
3276 combobox = lookup_widget(window1, "combobox1");
3277
3278 if(global_repo_cnt-1 > global_repo_nr)
3279 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), global_repo_nr+1);
3280 else
3281 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
3282
3283 }
3284
3285
3286 void
on_button58_clicked(GtkButton * button,gpointer user_data)3287 on_button58_clicked (GtkButton *button,
3288 gpointer user_data)
3289 {
3290 GtkWidget *combobox;
3291
3292 combobox = lookup_widget(window1, "combobox1");
3293
3294 if (global_repo_nr > 0)
3295 {
3296 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), global_repo_nr-1);
3297 }
3298 else
3299 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), global_repo_cnt-1);
3300 }
3301
3302 void
on_entry30_activate(GtkEntry * entry,gpointer user_data)3303 on_entry30_activate (GtkEntry *entry,
3304 gpointer user_data)
3305 {
3306 GtkWidget *widget;
3307
3308 widget = lookup_widget(GTK_WIDGET(entry), "okbutton10");
3309 gtk_button_clicked(GTK_BUTTON(widget));
3310 }
3311
3312
3313 void
on_cancelbutton9_clicked(GtkButton * button,gpointer user_data)3314 on_cancelbutton9_clicked (GtkButton *button,
3315 gpointer user_data)
3316 {
3317 GtkWidget *widget;
3318
3319 widget = lookup_widget(GTK_WIDGET(button), "dialog9");
3320 gtk_widget_destroy(widget);
3321 }
3322
3323 gboolean
on_eventbox5_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3324 on_eventbox5_button_release_event (GtkWidget *widget,
3325 GdkEventButton *event,
3326 gpointer user_data)
3327 {
3328 if(global_new_msg)
3329 {
3330 GtkWidget *widget;
3331
3332 if(!global_infopane_visible)
3333 {
3334 widget = lookup_widget(window1, "button76");
3335 g_signal_emit_by_name (widget, "clicked");
3336 }
3337
3338 gtk_widget_hide(global_infopane_current->data);
3339
3340 gtk_widget_show(g_list_nth_data(global_infopane_widgets, FRIENDS_PAGE));
3341 global_infopane_current = g_list_nth(global_infopane_widgets, FRIENDS_PAGE);
3342
3343 widget = lookup_widget(window1, "button35");
3344
3345 if(!msg_pane_visible)
3346 gtk_button_clicked(GTK_BUTTON(widget));
3347
3348 global_new_msg = FALSE;
3349 }
3350 return FALSE;
3351 }
3352
3353
3354 gboolean
on_item23_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3355 on_item23_button_release_event (GtkWidget *widget,
3356 GdkEventButton *event,
3357 gpointer user_data)
3358 {
3359 GtkWidget *label, *button, *entry, *cbox;
3360
3361 if (!dialog10)
3362 dialog10 = glade_xml_get_widget (gladexml, "dialog10");
3363
3364 gtk_widget_show(dialog10);
3365
3366 label = lookup_widget(dialog10, "label190");
3367 gtk_label_set_label(GTK_LABEL(label),"");
3368
3369 entry = lookup_widget(dialog10, "entry31");
3370 gtk_entry_set_text(GTK_ENTRY(entry),"");
3371 entry = lookup_widget(dialog10, "entry32");
3372 gtk_entry_set_text(GTK_ENTRY(entry),"");
3373
3374 button = lookup_widget(dialog10, "okbutton11");
3375 gtk_widget_set_sensitive(button, TRUE);
3376
3377 cbox = lookup_widget(GTK_WIDGET(button), "combobox8");
3378 gtk_combo_box_set_active(GTK_COMBO_BOX(cbox), 0);
3379
3380 if (gpsdata && gpsdata->fix.latitude !=0)
3381 {
3382 button = lookup_widget(dialog10, "button61");
3383 gtk_widget_set_sensitive(button, TRUE);
3384 }
3385
3386 return FALSE;
3387 }
3388
3389
3390 void
on_button59_clicked(GtkButton * button,gpointer user_data)3391 on_button59_clicked (GtkButton *button,
3392 gpointer user_data)
3393 {
3394 GtkWidget *widget;
3395
3396 widget = lookup_widget(GTK_WIDGET(button), "dialog10");
3397
3398 gtk_widget_hide(widget);
3399
3400 pickpoint_mode = TRUE;
3401 pickpoint = 1;
3402 }
3403
3404
3405 void
on_button60_clicked(GtkButton * button,gpointer user_data)3406 on_button60_clicked (GtkButton *button,
3407 gpointer user_data)
3408 {
3409 gtk_widget_hide(dialog10);
3410
3411 pickpoint_mode = TRUE;
3412 pickpoint = 2;
3413 }
3414
3415
3416 void
on_button61_clicked(GtkButton * button,gpointer user_data)3417 on_button61_clicked (GtkButton *button,
3418 gpointer user_data)
3419 {
3420 GtkWidget *widget = NULL;
3421
3422 widget = lookup_widget(dialog10, "entry31");
3423
3424 gtk_entry_set_text(GTK_ENTRY(widget),
3425 g_strdup_printf("%f,%f",gpsdata->fix.latitude,gpsdata->fix.longitude));
3426 }
3427
3428
3429 void
on_cancelbutton10_clicked(GtkButton * button,gpointer user_data)3430 on_cancelbutton10_clicked (GtkButton *button,
3431 gpointer user_data)
3432 {
3433 GtkWidget *widget;
3434
3435 widget = lookup_widget(GTK_WIDGET(button), "dialog10");
3436 gtk_widget_hide(widget);
3437 }
3438
3439
3440 void
on_okbutton11_clicked(GtkButton * button,gpointer user_data)3441 on_okbutton11_clicked (GtkButton *button,
3442 gpointer user_data)
3443 {
3444 GtkWidget *widget;
3445 char *start=NULL, *end=NULL;
3446 char *service=NULL;
3447
3448 gtk_widget_set_sensitive(GTK_WIDGET(button),FALSE);
3449
3450 widget = lookup_widget(GTK_WIDGET(button), "label190");
3451
3452 gtk_label_set_label (GTK_LABEL(widget),
3453 _("<b><i>Connecting...</i></b>"));
3454
3455 widget = lookup_widget(GTK_WIDGET(button), "entry31");
3456 start = g_strdup( gtk_entry_get_text(GTK_ENTRY(widget)) );
3457
3458 widget = lookup_widget(GTK_WIDGET(button), "entry32");
3459 end = g_strdup( gtk_entry_get_text(GTK_ENTRY(widget)) );
3460
3461 widget = lookup_widget(GTK_WIDGET(button), "combobox8");
3462 service = g_strdup (gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget)));
3463
3464 fetch_track (dialog10, service, start, end);
3465 }
3466
3467 void
do_pickpoint()3468 do_pickpoint()
3469 {
3470 GtkWidget *widget = NULL;
3471 float lat=0, lon=0;
3472
3473 lat = rad2deg( pixel2lat(global_zoom, global_y+mouse_y) );
3474 lon = rad2deg( pixel2lon(global_zoom, global_x+mouse_x) );
3475
3476 if (pickpoint == 1)
3477 widget = lookup_widget(dialog10, "entry31");
3478 if (pickpoint == 2)
3479 widget = lookup_widget(dialog10, "entry32");
3480
3481 gtk_entry_set_text(GTK_ENTRY(widget), g_strdup_printf("%f,%f",lat,lon));
3482
3483 if (pickpoint == 2)
3484 gtk_widget_grab_focus(widget);
3485
3486 gtk_widget_show(dialog10);
3487
3488 pickpoint_mode = FALSE;
3489 }
3490
3491 gboolean
on_dialog10_delete_event(GtkWidget * widget,GdkEvent * event,gpointer user_data)3492 on_dialog10_delete_event (GtkWidget *widget,
3493 GdkEvent *event,
3494 gpointer user_data)
3495 {
3496
3497 gtk_widget_hide_on_delete(widget);
3498 return TRUE;
3499 }
3500
3501 void
on_entry32_activate(GtkEntry * entry,gpointer user_data)3502 on_entry32_activate (GtkEntry *entry,
3503 gpointer user_data)
3504 {
3505 GtkWidget *widget;
3506
3507 widget = lookup_widget(dialog10, "okbutton11");
3508 gtk_button_clicked(GTK_BUTTON(widget));
3509 }
3510
3511 void
on_combobox8_changed(GtkComboBox * combobox,gpointer user_data)3512 on_combobox8_changed (GtkComboBox *combobox,
3513 gpointer user_data)
3514 {
3515
3516
3517
3518 }
3519
3520
3521 void
on_button76_clicked(GtkButton * button,gpointer user_data)3522 on_button76_clicked (GtkButton *button,
3523 gpointer user_data)
3524 {
3525
3526
3527 GtkWidget *widget, *widget1, *draw_widget, *toolbar;
3528
3529 widget = lookup_widget(window1, "vbox53");
3530 widget1 = lookup_widget(window1, "hbox52");
3531
3532 if(!global_infopane_visible)
3533 {
3534 if(window1->allocation.width <= 480)
3535 {
3536 gtk_widget_hide(widget1);
3537 gtk_widget_set_size_request(widget, window1->allocation.width, -1);
3538 }
3539 else
3540 gtk_widget_set_size_request(widget, 360, -1);
3541
3542 gtk_widget_show(widget);
3543
3544 if(!global_landscape) {
3545 toolbar = lookup_widget(window1, "toolbar1");
3546 gtk_widget_hide(toolbar);
3547 }
3548
3549 if(!global_infopane_current) {
3550 gtk_widget_show((GtkWidget *) global_infopane_widgets->data);
3551 global_infopane_current = global_infopane_widgets;
3552 }
3553
3554 global_infopane_visible = TRUE;
3555 }
3556 else {
3557 draw_widget = lookup_widget(window1, "drawingarea1");
3558
3559 gtk_widget_hide(widget);
3560 gtk_widget_show(widget1);
3561 gtk_widget_grab_focus(draw_widget);
3562
3563 if(!global_landscape) {
3564 toolbar = lookup_widget(window1, "toolbar1");
3565 gtk_widget_show(toolbar);
3566 }
3567
3568 global_infopane_visible = FALSE;
3569 }
3570 }
3571
3572
3573 void
on_button69_clicked(GtkButton * button,gpointer user_data)3574 on_button69_clicked (GtkButton *button,
3575 gpointer user_data)
3576 {
3577 gtk_widget_hide(global_infopane_current->data);
3578
3579 if(global_infopane_current->prev) {
3580 gtk_widget_show(global_infopane_current->prev->data);
3581 global_infopane_current = global_infopane_current->prev;
3582 }
3583 else {
3584 gtk_widget_show(g_list_last(global_infopane_widgets)->data);
3585 global_infopane_current = g_list_last(global_infopane_widgets);
3586 }
3587
3588 }
3589
3590
3591
3592
3593 void
on_button70_clicked(GtkButton * button,gpointer user_data)3594 on_button70_clicked (GtkButton *button,
3595 gpointer user_data)
3596 {
3597
3598 gtk_widget_hide(global_infopane_current->data);
3599
3600 if(global_infopane_current->next) {
3601 gtk_widget_show(global_infopane_current->next->data);
3602 global_infopane_current = global_infopane_current->next;
3603 }
3604 else {
3605 gtk_widget_show(global_infopane_widgets->data);
3606 global_infopane_current = global_infopane_widgets;
3607 }
3608
3609 }
3610
3611 void
on_checkbutton15_toggled(GtkToggleButton * togglebutton,gpointer user_data)3612 on_checkbutton15_toggled (GtkToggleButton *togglebutton,
3613 gpointer user_data)
3614 {
3615 GtkWidget *widget = NULL;
3616 gboolean active;
3617
3618 active = gtk_toggle_button_get_active(togglebutton);
3619
3620 widget = lookup_widget(window1, "entry8");
3621 gtk_entry_set_visibility (GTK_ENTRY (widget), active);
3622
3623 }
3624
3625 void
move_map(int i)3626 move_map(int i)
3627 {
3628 GtkWidget *widget = NULL;
3629 GtkToggleToolButton *autocenter_toggle;
3630
3631 widget = lookup_widget(window1, "drawingarea1");
3632
3633 if(i == 1)
3634 global_x += 80;
3635 else if(i == 3)
3636 global_x -= 80;
3637 else if(i == 2)
3638 global_y += 80;
3639 else if(i == 4)
3640 global_y -= 80;
3641
3642
3643 gdk_draw_rectangle (
3644 pixmap,
3645 widget->style->white_gc,
3646 TRUE,
3647 0, 0,
3648 widget->allocation.width+260,
3649 widget->allocation.height+260);
3650
3651 gtk_widget_queue_draw_area (
3652 widget,
3653 0,0,widget->allocation.width+260,widget->allocation.height+260);
3654
3655 autocenter_toggle =
3656 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1, "button3"));
3657 gtk_toggle_tool_button_set_active(autocenter_toggle, FALSE);
3658
3659 autocenter_toggle =
3660 GTK_TOGGLE_TOOL_BUTTON(lookup_widget(window1, "button56"));
3661 gtk_toggle_tool_button_set_active(autocenter_toggle, FALSE);
3662
3663 repaint_all();
3664 }
3665
3666 void
on_button78_clicked(GtkButton * button,gpointer user_data)3667 on_button78_clicked (GtkButton *button,
3668 gpointer user_data)
3669 {
3670
3671 }
3672
3673
3674 void
on_checkbutton16_toggled(GtkToggleButton * togglebutton,gpointer user_data)3675 on_checkbutton16_toggled (GtkToggleButton *togglebutton,
3676 gpointer user_data)
3677 {
3678 trip_livelog_on = gtk_toggle_button_get_active(togglebutton);
3679 }
3680
3681 void
tracklog_toolbutton_toggled(GtkToggleToolButton * button,gpointer data)3682 tracklog_toolbutton_toggled (GtkToggleToolButton *button, gpointer data)
3683 {
3684 GtkToggleButton *main_toggle =
3685 GTK_TOGGLE_BUTTON (lookup_widget (window1, "checkbutton17"));
3686
3687 trip_logger_on = gtk_toggle_tool_button_get_active (button);
3688
3689 gtk_toggle_button_set_active (main_toggle, trip_logger_on);
3690 }
3691
3692 void
on_checkbutton17_toggled(GtkToggleButton * togglebutton,gpointer user_data)3693 on_checkbutton17_toggled (GtkToggleButton *togglebutton,
3694 gpointer user_data)
3695 {
3696 GtkToggleToolButton *toolbar_toggle =
3697 GTK_TOGGLE_TOOL_BUTTON (lookup_widget (window1, "button62"));
3698
3699 trip_logger_on = gtk_toggle_button_get_active(togglebutton);
3700
3701 gtk_toggle_tool_button_set_active (toolbar_toggle, trip_logger_on);
3702
3703 if(trip_logger_on)
3704 {
3705 track_log_open();
3706 g_settings_set_boolean(
3707 global_settings,
3708 "tracklog-on",
3709 TRUE);
3710 }
3711 else
3712 {
3713 track_log_close();
3714 g_settings_set_boolean(
3715 global_settings,
3716 "tracklog-on",
3717 FALSE);
3718 }
3719 }
3720
3721
3722 void
on_button79_clicked(GtkButton * button,gpointer user_data)3723 on_button79_clicked (GtkButton *button,
3724 gpointer user_data)
3725 {
3726 GtkWidget *widget;
3727
3728 reset_loaded_track();
3729 gtk_widget_hide(GTK_WIDGET(button));
3730
3731 widget = lookup_widget(window1, "button78");
3732 gtk_widget_hide(widget);
3733
3734 widget = lookup_widget(window1, "label203");
3735 gtk_label_set_label(GTK_LABEL(widget), "");
3736
3737 repaint_all();
3738 }
3739
3740 void
on_entry29_changed(GtkEditable * editable,gpointer user_data)3741 on_entry29_changed (GtkEditable *editable,
3742 gpointer user_data)
3743 {
3744 const char *me_msg;
3745
3746 me_msg = gtk_entry_get_text(GTK_ENTRY(editable));
3747 g_settings_set_string(global_settings, "me-msg", me_msg);
3748 }
3749
3750 void
on_checkbutton18_toggled(GtkToggleButton * togglebutton,gpointer user_data)3751 on_checkbutton18_toggled (GtkToggleButton *togglebutton,
3752 gpointer user_data)
3753 {
3754 GtkWidget *widget;
3755
3756 hrm_on = gtk_toggle_button_get_active(togglebutton);
3757
3758 g_settings_set_boolean( global_settings,
3759 "hrm-on",
3760 hrm_on);
3761
3762 global_reconnect_hrm = TRUE;
3763
3764 widget = lookup_widget(window1, "label205");
3765 (hrm_on) ? gtk_widget_show(widget) : gtk_widget_hide(widget);
3766
3767 widget = lookup_widget(window1, "label206");
3768 (hrm_on) ? gtk_widget_show(widget) : gtk_widget_hide(widget);
3769
3770 widget = lookup_widget(window1, "label207");
3771 (hrm_on) ? gtk_widget_show(widget) : gtk_widget_hide(widget);
3772 }
3773
3774
3775 void
on_entry33_changed(GtkEditable * editable,gpointer user_data)3776 on_entry33_changed (GtkEditable *editable,
3777 gpointer user_data)
3778 {
3779 const char *entry;
3780
3781 entry = gtk_entry_get_text(GTK_ENTRY(editable));
3782
3783 g_settings_set_string(global_settings,
3784 "hrm-bt-addr",
3785 entry);
3786
3787 global_hrm_bt_addr = g_strdup(entry);
3788 global_reconnect_hrm = TRUE;
3789 }
3790
3791 void
set_map_detail_menuitem_sensitivity(GtkMenuItem * zoomout,GtkMenuItem * menu)3792 set_map_detail_menuitem_sensitivity (GtkMenuItem *zoomout, GtkMenuItem *menu)
3793 {
3794 gtk_widget_set_sensitive (GTK_WIDGET (zoomout),
3795 global_detail_zoom != 0);
3796 }
3797
3798 void
activate_more_map_details(GtkMenuItem * menu_item,gpointer user_data)3799 activate_more_map_details (GtkMenuItem *menu_item, gpointer user_data)
3800 {
3801 gboolean success = FALSE;
3802
3803 if (global_detail_zoom > 0) {
3804 global_detail_zoom--;
3805
3806 }
3807
3808 success = g_settings_set_int(
3809 global_settings,
3810 "global-detail-zoom",
3811 global_detail_zoom);
3812
3813 repaint_all ();
3814 }
3815
3816 void
activate_larger_map_details(GtkMenuItem * larger_item,GtkMenuItem * more_item)3817 activate_larger_map_details (GtkMenuItem *larger_item, GtkMenuItem *more_item)
3818 {
3819 gboolean success = FALSE;
3820
3821 global_detail_zoom++;
3822
3823 success = g_settings_set_int(
3824 global_settings,
3825 "global-detail-zoom",
3826 global_detail_zoom);
3827
3828 repaint_all ();
3829 }
3830
3831
3832 void
toggle_tile_redownload(GtkToggleButton * togglebutton,gpointer data)3833 toggle_tile_redownload (GtkToggleButton *togglebutton, gpointer data)
3834 {
3835 global_no_redownload = !gtk_toggle_button_get_active (togglebutton);
3836
3837 g_settings_set_boolean (global_settings,
3838 "no-redownload",
3839 global_no_redownload);
3840 }
3841
3842 gboolean
on_delete_waypoint_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3843 on_delete_waypoint_button_release_event (GtkWidget *widget,
3844 GdkEventButton *event,
3845 gpointer user_data)
3846 {
3847 delete_waypoint_of_route (selected_wp);
3848 selected_wp = NULL;
3849 repaint_all ();
3850
3851 return FALSE;
3852 }
3853
3854 gboolean
on_insert_waypoint_button_release_event(GtkWidget * widget,GdkEventButton * event,gpointer user_data)3855 on_insert_waypoint_button_release_event (GtkWidget *widget,
3856 GdkEventButton *event,
3857 gpointer user_data)
3858 {
3859 insert_waypoint_before_of_route (selected_wp);
3860 selected_wp = NULL;
3861 repaint_all ();
3862
3863 return FALSE;
3864 }
3865
3866 void
on_help_menuitem_activate(GtkMenuItem * help_menuitem,gpointer user_data)3867 on_help_menuitem_activate (GtkMenuItem *help_menuitem, gpointer user_data)
3868 {
3869 system ("xdg-open " PACKAGE_HTML_DIR "/" PACKAGE ".html");
3870 }
3871