← Back to branch summary

~foxtrotgps-team/foxtrotgps/trunk

« back to all changes in this revision

Viewing changes to src/tracks.c

  • Committer: Joshua Judson Rosen
  • Date: 2009-09-26 02:35:15 UTC
  • Revision ID: rozzin@geekspace.com-20090926023515-yxl5sg1a45gupuc8
Imported from tangogps-0.9.7 tarball.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tracks.c
 
1
 
 
2
#include <stdio.h>
 
3
#include <stdlib.h>
 
4
 
 
5
#include <gtk/gtk.h>
 
6
#include <glib.h>
 
7
#include <glib/gstdio.h>
 
8
 
 
9
#include <sys/types.h>
 
10
#include <sys/stat.h>
 
11
#include <fcntl.h>
 
12
 
 
13
#include "globals.h"
 
14
#include "tracks.h"
 
15
#include "interface.h"
 
16
#include "support.h"
 
17
#include "converter.h"
 
18
#include "map_management.h"
 
19
 
 
20
GSList *loaded_track;
 
21
GtkWidget *window12;
 
22
 
 
23
GtkWidget *
 
24
make_file_label(const char *file, char *full_file);
 
25
 
 
26
                                        
 
27
void
 
28
tracks_open_tracks_dialog()
 
29
{
 
30
        GDir *dir;
 
31
        GError *err = NULL;
 
32
        const char *file;
 
33
        gboolean isfile;
 
34
        GList *list = NULL;
 
35
 
 
36
        GtkWidget *label, *vbox, *eventbox;
 
37
        
 
38
 
 
39
        dir = g_dir_open(global_track_dir, 0, &err);
 
40
        
 
41
        if (err != NULL)
 
42
        {
 
43
                fprintf (stderr, "Problem opening directory: %s\n", err->message);
 
44
                g_error_free (err);
 
45
                return;
 
46
        }
 
47
        
 
48
        
 
49
        
 
50
        window12 = create_window12();
 
51
        gtk_widget_show(window12);
 
52
        
 
53
        vbox = lookup_widget(window12, "vbox39");               
 
54
        
 
55
        
 
56
        
 
57
        file = g_dir_read_name(dir);
 
58
 
 
59
        while (file)
 
60
        {
 
61
                isfile = g_file_test(g_strconcat(global_track_dir,file,NULL), G_FILE_TEST_IS_REGULAR);
 
62
                
 
63
                if(isfile)
 
64
                        list = g_list_insert_sorted( list, g_strdup(file), (GCompareFunc) g_strcmp0 );
 
65
 
 
66
                file = g_dir_read_name(dir);
 
67
        }
 
68
 
 
69
        for(; list!=NULL; list=list->next)
 
70
        {
 
71
                char *file = list->data;
 
72
                
 
73
                
 
74
                printf("%s \n", file);
 
75
                eventbox = gtk_event_box_new ();
 
76
                gtk_widget_set_events (eventbox, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK);
 
77
                gtk_widget_show (eventbox);
 
78
                
 
79
 
 
80
                gtk_box_pack_start (GTK_BOX (vbox), eventbox, FALSE, FALSE, 0);
 
81
                
 
82
                label = make_file_label(file, g_strconcat(global_track_dir,file,NULL));
 
83
                gtk_widget_show(label);
 
84
                gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
 
85
                gtk_misc_set_padding (GTK_MISC (label), 3, 2);
 
86
 
 
87
                gtk_container_add (GTK_CONTAINER (eventbox), label);
 
88
                
 
89
                g_signal_connect ((gpointer) eventbox, "button_release_event",
 
90
                                G_CALLBACK (tracks_on_file_button_release_event),
 
91
                                g_strconcat(global_track_dir,file,NULL));
 
92
        }
 
93
        
 
94
        g_list_free(list);
 
95
        g_dir_close(dir);
 
96
}
 
97
 
 
98
 
 
99
GtkWidget *
 
100
make_file_label(const char *file, char *full_file)
 
101
{
 
102
        GtkWidget *label;
 
103
        
 
104
        label = gtk_label_new (g_strdup(file));
 
105
        
 
106
        return label;
 
107
}
 
108
 
 
109
gboolean
 
110
tracks_on_file_button_release_event      (      GtkWidget       *widget,
 
111
                                        GdkEventButton  *event,
 
112
                                        gpointer         user_data)
 
113
{
 
114
        GtkWidget *drawingarea, *range;
 
115
        char *file;
 
116
        char line[121];
 
117
        char **arr;
 
118
        FILE *fd;
 
119
        float lat=0, lon=0, max_lat=-90, max_lon=-180, min_lat=90, min_lon=180, lat_tmp, lon_tmp;
 
120
        gboolean first_point = TRUE;
 
121
        int track_zoom, width, height;
 
122
        
 
123
        drawingarea = lookup_widget(window1, "drawingarea1");
 
124
        width  = drawingarea->allocation.width;
 
125
        height = drawingarea->allocation.height;
 
126
        
 
127
        file = (char *) user_data;
 
128
        
 
129
        g_slist_free(loaded_track);
 
130
        loaded_track = NULL;
 
131
 
 
132
        gtk_widget_destroy(window12);
 
133
 
 
134
        printf("+++++++++++++++++++++++++++++++++++++++++++ %s \n", file);
 
135
        fd = fopen(file, "r");
 
136
        while(fgets(line,120, fd))
 
137
        {
 
138
                
 
139
                trackpoint_t *tp = g_new0(trackpoint_t,1);
 
140
                
 
141
                arr = g_strsplit(line, ",", 2);
 
142
                
 
143
                
 
144
                if (arr[0] == NULL || arr[1] == NULL) continue;
 
145
 
 
146
                
 
147
                
 
148
                lat_tmp = atof(arr[0]);
 
149
                lon_tmp = atof(arr[1]);
 
150
                
 
151
                tp->lat = deg2rad(lat_tmp);
 
152
                tp->lon = deg2rad(lon_tmp);
 
153
                
 
154
                if(first_point)
 
155
                {
 
156
                        lat = atof(arr[0]);
 
157
                        lon = atof(arr[1]);
 
158
                        first_point = FALSE;
 
159
                }
 
160
                
 
161
                max_lat = (lat_tmp>max_lat) ? lat_tmp : max_lat;
 
162
                min_lat = (lat_tmp<min_lat) ? lat_tmp : min_lat;
 
163
                max_lon = (lon_tmp>max_lon) ? lon_tmp : max_lon;
 
164
                min_lon = (lon_tmp<min_lon) ? lon_tmp : min_lon;
 
165
                
 
166
                
 
167
                loaded_track = g_slist_append(loaded_track, tp);
 
168
        }
 
169
        
 
170
        gtk_notebook_set_current_page(GTK_NOTEBOOK(lookup_widget(window1,"notebook1")), 0);
 
171
 
 
172
 
 
173
        
 
174
        
 
175
        
 
176
        track_zoom = get_zoom_covering(width, height, max_lat, min_lon, min_lat, max_lon);
 
177
        track_zoom = (track_zoom > 15) ? 15 : track_zoom;
 
178
        
 
179
        if(lat!=0 && lon!=0)
 
180
                set_mapcenter((max_lat+min_lat)/2, (max_lon+min_lon)/2, track_zoom);
 
181
 
 
182
printf("%.0f - %.0f ## %.0f - %.0f\n",max_lat,max_lon,min_lat,min_lon);
 
183
                
 
184
                        range = lookup_widget(window1, "vscale1");
 
185
                gtk_range_set_value(GTK_RANGE(range), (double) global_zoom);
 
186
        
 
187
        paint_loaded_track();
 
188
        
 
189
        
 
190
        return FALSE;   
 
191
}
 
192
 
 
193
 
 
194
void
 
195
paint_loaded_track()
 
196
{
 
197
        
 
198
        GSList *list;
 
199
        int pixel_x, pixel_y, x,y, last_x = 0, last_y = 0;
 
200
        float lat, lon;
 
201
        GdkColor color;
 
202
        GdkGC *gc;
 
203
        gboolean is_line = FALSE;
 
204
        
 
205
        gc = gdk_gc_new(pixmap);
 
206
        color.green = 50000;
 
207
        color.blue = 0;
 
208
        color.red = 0;
 
209
        gdk_gc_set_rgb_fg_color(gc, &color);
 
210
        gdk_gc_set_line_attributes(gc,
 
211
                5, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND);
 
212
 
 
213
        
 
214
 
 
215
        printf("*** %s(): \n",__PRETTY_FUNCTION__);
 
216
 
 
217
        for(list = loaded_track; list != NULL; list = list->next)
 
218
        {
 
219
                trackpoint_t *tp = list->data;
 
220
        
 
221
                lat = tp->lat;
 
222
                lon = tp->lon;
 
223
                
 
224
                
 
225
                
 
226
                
 
227
                pixel_x = lon2pixel(global_zoom, lon);
 
228
                pixel_y = lat2pixel(global_zoom, lat);
 
229
                
 
230
                x = pixel_x - global_x;
 
231
                y = pixel_y - global_y;
 
232
                
 
233
 
 
234
                if(is_line)
 
235
                {
 
236
                        gdk_draw_line (pixmap, gc, x, y, last_x, last_y);
 
237
                        gtk_widget_queue_draw_area (
 
238
                                map_drawable, 
 
239
                                x-4, y-4,
 
240
                                8,8);
 
241
                        
 
242
                }
 
243
                
 
244
                last_x = x;
 
245
                last_y = y;
 
246
                
 
247
                
 
248
                is_line = TRUE;
 
249
        }
 
250
}