osm2go/src/track.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of OSM2Go.
 *
 * OSM2Go is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OSM2Go is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OSM2Go.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <libxml/parser.h>
#include <libxml/tree.h>

#include "appdata.h"

#ifndef LIBXML_TREE_ENABLED
#error "Tree not enabled in libxml"
#endif

/* enable/disable menu with respect to mode */
void track_set_mode(appdata_t *appdata, track_t *track, track_mode_t mode) {
  /* import and gps are always enabled */
  const gboolean clear[]  = { FALSE, TRUE,  TRUE };
  const gboolean export[] = { FALSE, FALSE, TRUE };

  gtk_widget_set_sensitive(appdata->track.menu_item_clear, clear[mode]);
  gtk_widget_set_sensitive(appdata->track.menu_item_export, export[mode]);

  /* adjust menu item if required */
  if((mode == TRACK_GPS) && 
     !gtk_check_menu_item_get_active(
                    GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps)))
     gtk_check_menu_item_set_active(
                    GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps), TRUE);

  if((mode != TRACK_GPS) && 
     gtk_check_menu_item_get_active(
                    GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps)))
     gtk_check_menu_item_set_active(
                    GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps), FALSE);

  if(track)
    track->mode = mode;
}

gint track_seg_points(track_seg_t *seg) {
  gint points = 0;

  track_point_t *point = seg->track_point;
  while(point) {
    points++;
    point = point->next;
  }
  return points;
}

static gboolean track_get_prop_pos(xmlNode *node, pos_t *pos) {
  char *str_lat = (char*)xmlGetProp(node, BAD_CAST "lat");
  char *str_lon = (char*)xmlGetProp(node, BAD_CAST "lon");

  if(!str_lon || !str_lat) {
    if(!str_lon) xmlFree(str_lon);
    if(!str_lat) xmlFree(str_lat);
    return FALSE;
  }

  pos->lat = g_ascii_strtod(str_lat, NULL);
  pos->lon = g_ascii_strtod(str_lon, NULL);

  xmlFree(str_lon);
  xmlFree(str_lat);

  return TRUE;
}

static track_point_t *track_parse_trkpt(bounds_t *bounds, xmlDocPtr doc, 
                                        xmlNode *a_node) {
  track_point_t *point = NULL;
  pos_t pos;

  /* parse position */
  if(!track_get_prop_pos(a_node, &pos)) 
    return NULL;

  point = g_new0(track_point_t, 1);

  pos2lpos(bounds, &pos, &point->lpos);

  /* check if point is within bounds */
  if((point->lpos.x < bounds->min.x) || (point->lpos.x > bounds->max.x) ||
     (point->lpos.y < bounds->min.y) || (point->lpos.y > bounds->max.y)) {
    g_free(point);
    point = NULL;
  }

  return point;
}

static void track_parse_trkseg(track_t *track, bounds_t *bounds, 
                               xmlDocPtr doc, xmlNode *a_node) {
  xmlNode *cur_node = NULL;
  track_point_t **point = NULL;
  track_seg_t **seg = &(track->track_seg);

  /* search end of track_seg list */
  while(*seg) seg = &((*seg)->next);

  for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "trkpt") == 0) {
        track_point_t *cpnt = track_parse_trkpt(bounds, doc, cur_node);
        if(cpnt) {
          if(!point) {
            /* start a new segment */
            *seg = g_new0(track_seg_t, 1);
            point = &((*seg)->track_point);
          }
          /* attach point to chain */
          *point = cpnt;
          point = &((*point)->next);
        } else {
          /* end segment if point could not be parsed and start a new one */
          /* close segment if there is one */
          if(point) {
            printf("ending track segment leaving bounds\n");
            seg = &((*seg)->next);
            point = NULL;
          }
        }
      } else
        printf("found unhandled gpx/trk/trkseg/%s\n", cur_node->name);
      
    }
  }
}

static track_t *track_parse_trk(bounds_t *bounds, 
                                xmlDocPtr doc, xmlNode *a_node) {
  track_t *track = g_new0(track_t, 1);
  xmlNode *cur_node = NULL;

  for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "trkseg") == 0) {
        track_parse_trkseg(track, bounds, doc, cur_node);
      } else
        printf("found unhandled gpx/trk/%s\n", cur_node->name);
      
    }
  }
  return track;
}

static track_t *track_parse_gpx(bounds_t *bounds, 
                                xmlDocPtr doc, xmlNode *a_node) {
  track_t *track = NULL;
  xmlNode *cur_node = NULL;

  for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "trk") == 0) {
        if(!track) 
          track = track_parse_trk(bounds, doc, cur_node);
        else
          printf("ignoring additional track\n");
      } else
        printf("found unhandled gpx/%s\n", cur_node->name);      
    }
  }
  return track;
}

/* parse root element and search for "track" */
static track_t *track_parse_root(bounds_t *bounds, 
                                 xmlDocPtr doc, xmlNode *a_node) {
  track_t *track = NULL;
  xmlNode *cur_node = NULL;

  for (cur_node = a_node; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      /* parse track file ... */
      if(strcasecmp((char*)cur_node->name, "gpx") == 0) 
        track = track_parse_gpx(bounds, doc, cur_node);
      else 
        printf("found unhandled %s\n", cur_node->name);
    }
  }
  return track;
}

static track_t *track_parse_doc(bounds_t *bounds, xmlDocPtr doc) {
  track_t *track;

  /* Get the root element node */
  xmlNode *root_element = xmlDocGetRootElement(doc);

  track = track_parse_root(bounds, doc, root_element);  

  /*free the document */
  xmlFreeDoc(doc);

  /*
   * Free the global variables that may
   * have been allocated by the parser.
   */
  xmlCleanupParser();

  return track;
}

void track_info(track_t *track) {
  printf("Loaded track: %s\n", track->filename);
  printf("Track has %sbeen saved in project.\n", track->saved?"":"not ");

  gint segs = 0, points = 0;
  track_seg_t *seg = track->track_seg;
  while(seg) {
    points += track_seg_points(seg);
    segs++;
    seg = seg->next;
  }

  printf("%d points in %d segments\n", points, segs);

}

static track_t *track_import(osm_t *osm, char *filename) {
  printf("============================================================\n");
  printf("loading track %s\n", filename);
 
  xmlDoc *doc = NULL;

  LIBXML_TEST_VERSION;
  
  /* parse the file and get the DOM */
  if((doc = xmlReadFile(filename, NULL, 0)) == NULL) {
    xmlErrorPtr errP = xmlGetLastError();
    errorf(NULL, "While parsing \"%s\":\n\n%s", filename, errP->message);
    return NULL;
  }

  track_t *track = track_parse_doc(osm->bounds, doc); 
  track->filename = g_strdup(filename);
  track->saved = FALSE;

  track_info(track);
  
  return track;
}

void track_point_free(track_point_t *point) {
  g_free(point);
}

void track_seg_free(track_seg_t *seg) {
  track_point_t *point = seg->track_point;
  while(point) {
    track_point_t *next = point->next;
    track_point_free(point);
    point = next;
  }

  g_free(seg);
}

/* --------------------------------------------------------------- */

static void track_clear(appdata_t *appdata, track_t *track) {
  printf("clearing track\n");

  if(appdata->map)
    map_track_remove(appdata);

  track_seg_t *seg = track->track_seg;
  while(seg) {
    track_seg_t *next = seg->next;
    track_seg_free(seg);
    seg = next;
  }

  g_free(track->filename);
  g_free(track);
}

/* ----------------------  saving track --------------------------- */

void track_save_points(track_point_t *point, xmlNodePtr node) {
  while(point) {
    xmlNodePtr node_point = xmlNewChild(node, NULL, BAD_CAST "point", NULL);
 
    char *str = g_strdup_printf("%d", point->lpos.x);
    xmlNewProp(node_point, BAD_CAST "x", BAD_CAST str);
    g_free(str);
    
    str = g_strdup_printf("%d", point->lpos.y);
    xmlNewProp(node_point, BAD_CAST "y", BAD_CAST str);
    g_free(str);

    point = point->next;
  }
}

void track_save_segs(track_seg_t *seg, xmlNodePtr node) {
  while(seg) {
    xmlNodePtr node_seg = xmlNewChild(node, NULL, BAD_CAST "seg", NULL);
    track_save_points(seg->track_point, node_seg);
    seg = seg->next;
  }
}

/* save track in project */
void track_save(project_t *project, track_t *track) {
  if(!project) return;

  char *trk_name = g_strdup_printf("%s/%s.trk", project->path, project->name);

  if(!track) {
    g_remove(trk_name);
    g_free(trk_name);
    return;
  }

  /* no need to save again if it has already been saved */
  if(track->saved) {
    printf("track already saved, don't save it again\n");
    g_free(trk_name);
    return;
  }

  printf("saving track\n");

  LIBXML_TEST_VERSION;
 
  xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
  xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "trk");
  xmlNewProp(root_node, BAD_CAST "filename", BAD_CAST track->filename);
  char *mode_str = g_strdup_printf("%d", track->mode);
  xmlNewProp(root_node, BAD_CAST "mode", BAD_CAST mode_str);
  g_free(mode_str);
  xmlDocSetRootElement(doc, root_node);
  
  track_save_segs(track->track_seg, root_node);

  xmlSaveFormatFileEnc(trk_name, doc, "UTF-8", 1);
  xmlFreeDoc(doc);
  xmlCleanupParser();

  g_free(trk_name);

  track->saved = TRUE;
}

/* ----------------------  loading track --------------------------- */

static int xml_get_prop_int(xmlNode *node, char *prop) {
  char *str = (char*)xmlGetProp(node, BAD_CAST prop);
  int value = 0;

  if(str) {
    value = strtoul(str, NULL, 10);
    xmlFree(str);
  }

  return value;
}

track_t *track_restore(appdata_t *appdata, project_t *project) {
  char *trk_name = g_strdup_printf("%s/%s.trk", project->path, project->name);
  track_t *track = NULL;
  
  LIBXML_TEST_VERSION;
 
  if(!g_file_test(trk_name, G_FILE_TEST_EXISTS)) {
    printf("no track present!\n");
    g_free(trk_name);
    return NULL;
  }
  
  printf("track found, loading ...\n");
  
  xmlDoc *doc = NULL;
  xmlNode *root_element = NULL;
  
  /* parse the file and get the DOM */
  if((doc = xmlReadFile(trk_name, NULL, 0)) == NULL) {
    errorf(GTK_WIDGET(appdata->window), 
           "Error: could not parse file %s\n", trk_name);
    g_free(trk_name);
    return NULL;
  }
  
  /* Get the root element node */
  root_element = xmlDocGetRootElement(doc);
  
  xmlNode *cur_node = NULL;
  for (cur_node = root_element; cur_node; cur_node = cur_node->next) {
    if (cur_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)cur_node->name, "trk") == 0) {
        printf("found track\n");

        track = g_new0(track_t, 1);
        track->mode = xml_get_prop_int(cur_node, "mode");

        char *str = (char*)xmlGetProp(cur_node, BAD_CAST "filename");
        if(str) {
          track->filename = g_strdup(str);
          xmlFree(str);
        }

        xmlNodePtr seg_node = cur_node->children;
        track_seg_t **seg = &track->track_seg;
        while(seg_node) {
          if(seg_node->type == XML_ELEMENT_NODE) {

            if(strcasecmp((char*)seg_node->name, "seg") == 0) {
              *seg = g_new0(track_seg_t, 1);

              xmlNodePtr point_node = seg_node->children;
              track_point_t **point = &(*seg)->track_point;
              while(point_node) {
                if(point_node->type == XML_ELEMENT_NODE) {

                  if(strcasecmp((char*)point_node->name, "point") == 0) {
                    *point = g_new0(track_point_t, 1);
                    (*point)->lpos.x = xml_get_prop_int(point_node, "x");
                    (*point)->lpos.y = xml_get_prop_int(point_node, "y");

                    point = &((*point)->next);
                  }
                }
                point_node = point_node->next;
              }

              seg = &((*seg)->next);
            }
          }
          seg_node = seg_node->next;
        }
      }
    }
  }

  g_free(trk_name);

  printf("restoring track mode %d\n", track->mode);
  track_set_mode(appdata, track, track->mode);
  track->saved = TRUE;
  track_info(track);

  return track;
}

static void track_end_segment(track_t *track) {
  if(track->cur_seg) {
    printf("ending a segment\n");
   
    /* todo: check if segment only has 1 point */
 
    track->cur_seg = NULL;
  }
}

static void track_append_position(appdata_t *appdata, pos_t *pos) {
  track_t *track = appdata->track.track;

  if(!track->cur_seg) {
    printf("starting new segment\n");
    
    track_seg_t **seg = &(track->track_seg);
    while(*seg) seg = &((*seg)->next);

    *seg = track->cur_seg = g_new0(track_seg_t, 1);
  } else
    printf("appending to current segment\n");

  gint seg_len = 0;
  track_point_t **point = &(track->cur_seg->track_point);
  while(*point) { seg_len++; point = &((*point)->next); }

  /* create utm coordinates */
  lpos_t lpos;
  bounds_t *bounds = appdata->osm->bounds;
  pos2lpos(bounds, pos, &lpos);

  /* check if point is within bounds */
  if((lpos.x < bounds->min.x) || (lpos.x > bounds->max.x) ||
     (lpos.y < bounds->min.y) || (lpos.y > bounds->max.y)) {
    printf("position out of bounds\n");

    /* end segment */
    track_end_segment(track);
    map_track_pos(appdata, NULL);
  } else {
    map_track_pos(appdata, &lpos);

    /* don't append if point is the same as last time */
    track_point_t *prev = track->cur_seg->track_point;
    while(prev && prev->next) prev = prev->next;

    if(prev && prev->lpos.x == lpos.x && prev->lpos.y == lpos.y) {
      printf("same value as last point -> ignore\n");
    } else {

      *point = g_new0(track_point_t, 1);
      (*point)->lpos.x = lpos.x;
      (*point)->lpos.y = lpos.y;
      track->saved = FALSE;

      /* if segment length was 1 the segment can now be drawn for the first time */
      if(seg_len <= 1) {
        printf("initial/second draw with seg_len %d\n", seg_len);

        if(seg_len == 0) g_assert(!track->cur_seg->item);
        else             g_assert(track->cur_seg->item);

        map_track_draw_seg(appdata->map, track->cur_seg);
      }
      
      /* if segment length was > 1 the segment has to be updated */
      if(seg_len > 1) {
        printf("update draw\n");
        
        g_assert(track->cur_seg->item);
        map_track_update_seg(appdata->map, track->cur_seg);
      }
    }
  }
}

static gboolean update(gpointer data) {
  appdata_t *appdata = (appdata_t*)data;

  pos_t *pos = gps_get_pos(appdata);
  if(pos) {
    printf("valid position %f/%f\n", pos->lat, pos->lon);
    track_append_position(appdata, pos);
  } else {
    printf("no valid position\n");
    /* end segment */
    track_end_segment(appdata->track.track);
    map_track_pos(appdata, NULL);
  }

  return TRUE;
}

static void track_enable_gps(appdata_t *appdata) {
  appdata->gps_enabled = TRUE;

  if(!appdata->track.handler_id) {
    appdata->track.handler_id = gtk_timeout_add(1000, update, appdata);

    if(appdata->track.track) {
      printf("there's already a track -> restored!!\n");
      map_track_draw(appdata->map, appdata->track.track);
    } else
      appdata->track.track = g_new0(track_t, 1);
  }
}

static void track_disable_gps(appdata_t *appdata) {
  appdata->gps_enabled = FALSE;

  if(appdata->track.handler_id) {
    gtk_timeout_remove(appdata->track.handler_id);
    appdata->track.handler_id = 0;
  }
}

void track_do(appdata_t *appdata, track_mode_t mode, char *name) {

  printf("track do %d\n", mode);

  /* remove existing track */
  if(appdata->track.track) {
    track_clear(appdata, appdata->track.track);
    appdata->track.track = NULL;
    map_track_pos(appdata, NULL);
  }

  switch(mode) {
  case TRACK_NONE:
    /* disable gps if it was on */
    track_disable_gps(appdata);    

    track_set_mode(appdata, appdata->track.track, TRACK_NONE);     
    break;

  case TRACK_IMPORT:
    /* disable gps if it was on */
    track_disable_gps(appdata);    

    appdata->track.track = track_import(appdata->osm, name);
    map_track_draw(appdata->map, appdata->track.track);
    track_set_mode(appdata, appdata->track.track, TRACK_IMPORT);
   break;

  case TRACK_GPS:
    track_enable_gps(appdata);    

    track_set_mode(appdata, appdata->track.track, TRACK_GPS);
    break;
  }
}
1	harbaum	1	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of OSM2Go.
5			*
6			* OSM2Go is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* OSM2Go is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with OSM2Go. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			#include <libxml/parser.h>
21			#include <libxml/tree.h>
22
23			#include "appdata.h"
24
25			#ifndef LIBXML_TREE_ENABLED
26			#error "Tree not enabled in libxml"
27			#endif
28
29			/* enable/disable menu with respect to mode */
30			void track_set_mode(appdata_t appdata, track_t track, track_mode_t mode) {
31			/* import and gps are always enabled */
32			const gboolean clear[] = { FALSE, TRUE, TRUE };
33			const gboolean export[] = { FALSE, FALSE, TRUE };
34
35			gtk_widget_set_sensitive(appdata->track.menu_item_clear, clear[mode]);
36			gtk_widget_set_sensitive(appdata->track.menu_item_export, export[mode]);
37
38			/* adjust menu item if required */
39			if((mode == TRACK_GPS) &&
40			!gtk_check_menu_item_get_active(
41			GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps)))
42			gtk_check_menu_item_set_active(
43			GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps), TRUE);
44
45			if((mode != TRACK_GPS) &&
46			gtk_check_menu_item_get_active(
47			GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps)))
48			gtk_check_menu_item_set_active(
49			GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps), FALSE);
50
51			if(track)
52			track->mode = mode;
53			}
54
55			gint track_seg_points(track_seg_t *seg) {
56			gint points = 0;
57
58			track_point_t *point = seg->track_point;
59			while(point) {
60			points++;
61			point = point->next;
62			}
63			return points;
64			}
65
66			static gboolean track_get_prop_pos(xmlNode node, pos_t pos) {
67			char str_lat = (char)xmlGetProp(node, BAD_CAST "lat");
68			char str_lon = (char)xmlGetProp(node, BAD_CAST "lon");
69
70			if(!str_lon \|\| !str_lat) {
71			if(!str_lon) xmlFree(str_lon);
72			if(!str_lat) xmlFree(str_lat);
73			return FALSE;
74			}
75
76			pos->lat = g_ascii_strtod(str_lat, NULL);
77			pos->lon = g_ascii_strtod(str_lon, NULL);
78
79			xmlFree(str_lon);
80			xmlFree(str_lat);
81
82			return TRUE;
83			}
84
85			static track_point_t track_parse_trkpt(bounds_t bounds, xmlDocPtr doc,
86			xmlNode *a_node) {
87			track_point_t *point = NULL;
88			pos_t pos;
89
90			/* parse position */
91			if(!track_get_prop_pos(a_node, &pos))
92			return NULL;
93
94			point = g_new0(track_point_t, 1);
95
96			pos2lpos(bounds, &pos, &point->lpos);
97
98			/* check if point is within bounds */
99			if((point->lpos.x < bounds->min.x) \|\| (point->lpos.x > bounds->max.x) \|\|
100			(point->lpos.y < bounds->min.y) \|\| (point->lpos.y > bounds->max.y)) {
101			g_free(point);
102			point = NULL;
103			}
104
105			return point;
106			}
107
108			static void track_parse_trkseg(track_t track, bounds_t bounds,
109			xmlDocPtr doc, xmlNode *a_node) {
110			xmlNode *cur_node = NULL;
111			track_point_t **point = NULL;
112			track_seg_t **seg = &(track->track_seg);
113
114			/* search end of track_seg list */
115			while(seg) seg = &((seg)->next);
116
117			for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
118			if (cur_node->type == XML_ELEMENT_NODE) {
119			if(strcasecmp((char*)cur_node->name, "trkpt") == 0) {
120			track_point_t *cpnt = track_parse_trkpt(bounds, doc, cur_node);
121			if(cpnt) {
122			if(!point) {
123			/* start a new segment */
124			*seg = g_new0(track_seg_t, 1);
125			point = &((*seg)->track_point);
126			}
127			/* attach point to chain */
128			*point = cpnt;
129			point = &((*point)->next);
130			} else {
131			/* end segment if point could not be parsed and start a new one */
132			/* close segment if there is one */
133			if(point) {
134			printf("ending track segment leaving bounds\n");
135			seg = &((*seg)->next);
136			point = NULL;
137			}
138			}
139			} else
140			printf("found unhandled gpx/trk/trkseg/%s\n", cur_node->name);
141
142			}
143			}
144			}
145
146			static track_t track_parse_trk(bounds_t bounds,
147			xmlDocPtr doc, xmlNode *a_node) {
148			track_t *track = g_new0(track_t, 1);
149			xmlNode *cur_node = NULL;
150
151			for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
152			if (cur_node->type == XML_ELEMENT_NODE) {
153			if(strcasecmp((char*)cur_node->name, "trkseg") == 0) {
154			track_parse_trkseg(track, bounds, doc, cur_node);
155			} else
156			printf("found unhandled gpx/trk/%s\n", cur_node->name);
157
158			}
159			}
160			return track;
161			}
162
163			static track_t track_parse_gpx(bounds_t bounds,
164			xmlDocPtr doc, xmlNode *a_node) {
165			track_t *track = NULL;
166			xmlNode *cur_node = NULL;
167
168			for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
169			if (cur_node->type == XML_ELEMENT_NODE) {
170			if(strcasecmp((char*)cur_node->name, "trk") == 0) {
171			if(!track)
172			track = track_parse_trk(bounds, doc, cur_node);
173			else
174			printf("ignoring additional track\n");
175			} else
176			printf("found unhandled gpx/%s\n", cur_node->name);
177			}
178			}
179			return track;
180			}
181
182			/* parse root element and search for "track" */
183			static track_t track_parse_root(bounds_t bounds,
184			xmlDocPtr doc, xmlNode *a_node) {
185			track_t *track = NULL;
186			xmlNode *cur_node = NULL;
187
188			for (cur_node = a_node; cur_node; cur_node = cur_node->next) {
189			if (cur_node->type == XML_ELEMENT_NODE) {
190			/* parse track file ... */
191			if(strcasecmp((char*)cur_node->name, "gpx") == 0)
192			track = track_parse_gpx(bounds, doc, cur_node);
193			else
194			printf("found unhandled %s\n", cur_node->name);
195			}
196			}
197			return track;
198			}
199
200			static track_t track_parse_doc(bounds_t bounds, xmlDocPtr doc) {
201			track_t *track;
202
203			/* Get the root element node */
204			xmlNode *root_element = xmlDocGetRootElement(doc);
205
206			track = track_parse_root(bounds, doc, root_element);
207
208			/free the document /
209			xmlFreeDoc(doc);
210
211			/*
212			* Free the global variables that may
213			* have been allocated by the parser.
214			*/
215			xmlCleanupParser();
216
217			return track;
218			}
219
220			void track_info(track_t *track) {
221			printf("Loaded track: %s\n", track->filename);
222			printf("Track has %sbeen saved in project.\n", track->saved?"":"not ");
223
224			gint segs = 0, points = 0;
225			track_seg_t *seg = track->track_seg;
226			while(seg) {
227			points += track_seg_points(seg);
228			segs++;
229			seg = seg->next;
230			}
231
232			printf("%d points in %d segments\n", points, segs);
233
234			}
235
236			static track_t track_import(osm_t osm, char *filename) {
237			printf("============================================================\n");
238			printf("loading track %s\n", filename);
239
240			xmlDoc *doc = NULL;
241
242			LIBXML_TEST_VERSION;
243
244			/* parse the file and get the DOM */
245			if((doc = xmlReadFile(filename, NULL, 0)) == NULL) {
246			xmlErrorPtr errP = xmlGetLastError();
247			errorf(NULL, "While parsing \"%s\":\n\n%s", filename, errP->message);
248			return NULL;
249			}
250
251			track_t *track = track_parse_doc(osm->bounds, doc);
252			track->filename = g_strdup(filename);
253			track->saved = FALSE;
254
255			track_info(track);
256
257			return track;
258			}
259
260			void track_point_free(track_point_t *point) {
261			g_free(point);
262			}
263
264			void track_seg_free(track_seg_t *seg) {
265			track_point_t *point = seg->track_point;
266			while(point) {
267			track_point_t *next = point->next;
268			track_point_free(point);
269			point = next;
270			}
271
272			g_free(seg);
273			}
274
275			/* --------------------------------------------------------------- */
276
277			static void track_clear(appdata_t appdata, track_t track) {
278			printf("clearing track\n");
279
280			if(appdata->map)
281			map_track_remove(appdata);
282
283			track_seg_t *seg = track->track_seg;
284			while(seg) {
285			track_seg_t *next = seg->next;
286			track_seg_free(seg);
287			seg = next;
288			}
289
290			g_free(track->filename);
291			g_free(track);
292			}
293
294			/* ---------------------- saving track --------------------------- */
295
296			void track_save_points(track_point_t *point, xmlNodePtr node) {
297			while(point) {
298			xmlNodePtr node_point = xmlNewChild(node, NULL, BAD_CAST "point", NULL);
299
300			char *str = g_strdup_printf("%d", point->lpos.x);
301			xmlNewProp(node_point, BAD_CAST "x", BAD_CAST str);
302			g_free(str);
303
304			str = g_strdup_printf("%d", point->lpos.y);
305			xmlNewProp(node_point, BAD_CAST "y", BAD_CAST str);
306			g_free(str);
307
308			point = point->next;
309			}
310			}
311
312			void track_save_segs(track_seg_t *seg, xmlNodePtr node) {
313			while(seg) {
314			xmlNodePtr node_seg = xmlNewChild(node, NULL, BAD_CAST "seg", NULL);
315			track_save_points(seg->track_point, node_seg);
316			seg = seg->next;
317			}
318			}
319
320			/* save track in project */
321			void track_save(project_t project, track_t track) {
322			if(!project) return;
323
324			char *trk_name = g_strdup_printf("%s/%s.trk", project->path, project->name);
325
326			if(!track) {
327			g_remove(trk_name);
328			g_free(trk_name);
329			return;
330			}
331
332			/* no need to save again if it has already been saved */
333			if(track->saved) {
334			printf("track already saved, don't save it again\n");
335			g_free(trk_name);
336			return;
337			}
338
339			printf("saving track\n");
340
341			LIBXML_TEST_VERSION;
342
343			xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
344			xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "trk");
345			xmlNewProp(root_node, BAD_CAST "filename", BAD_CAST track->filename);
346			char *mode_str = g_strdup_printf("%d", track->mode);
347			xmlNewProp(root_node, BAD_CAST "mode", BAD_CAST mode_str);
348			g_free(mode_str);
349			xmlDocSetRootElement(doc, root_node);
350
351			track_save_segs(track->track_seg, root_node);
352
353			xmlSaveFormatFileEnc(trk_name, doc, "UTF-8", 1);
354			xmlFreeDoc(doc);
355			xmlCleanupParser();
356
357			g_free(trk_name);
358
359			track->saved = TRUE;
360			}
361
362			/* ---------------------- loading track --------------------------- */
363
364			static int xml_get_prop_int(xmlNode node, char prop) {
365			char str = (char)xmlGetProp(node, BAD_CAST prop);
366			int value = 0;
367
368			if(str) {
369			value = strtoul(str, NULL, 10);
370			xmlFree(str);
371			}
372
373			return value;
374			}
375
376			track_t track_restore(appdata_t appdata, project_t *project) {
377			char *trk_name = g_strdup_printf("%s/%s.trk", project->path, project->name);
378			track_t *track = NULL;
379
380			LIBXML_TEST_VERSION;
381
382			if(!g_file_test(trk_name, G_FILE_TEST_EXISTS)) {
383			printf("no track present!\n");
384			g_free(trk_name);
385			return NULL;
386			}
387
388			printf("track found, loading ...\n");
389
390			xmlDoc *doc = NULL;
391			xmlNode *root_element = NULL;
392
393			/* parse the file and get the DOM */
394			if((doc = xmlReadFile(trk_name, NULL, 0)) == NULL) {
395			errorf(GTK_WIDGET(appdata->window),
396			"Error: could not parse file %s\n", trk_name);
397			g_free(trk_name);
398			return NULL;
399			}
400
401			/* Get the root element node */
402			root_element = xmlDocGetRootElement(doc);
403
404			xmlNode *cur_node = NULL;
405			for (cur_node = root_element; cur_node; cur_node = cur_node->next) {
406			if (cur_node->type == XML_ELEMENT_NODE) {
407			if(strcasecmp((char*)cur_node->name, "trk") == 0) {
408			printf("found track\n");
409
410			track = g_new0(track_t, 1);
411			track->mode = xml_get_prop_int(cur_node, "mode");
412
413			char str = (char)xmlGetProp(cur_node, BAD_CAST "filename");
414			if(str) {
415			track->filename = g_strdup(str);
416			xmlFree(str);
417			}
418
419			xmlNodePtr seg_node = cur_node->children;
420			track_seg_t **seg = &track->track_seg;
421			while(seg_node) {
422			if(seg_node->type == XML_ELEMENT_NODE) {
423
424			if(strcasecmp((char*)seg_node->name, "seg") == 0) {
425			*seg = g_new0(track_seg_t, 1);
426
427			xmlNodePtr point_node = seg_node->children;
428			track_point_t *point = &(seg)->track_point;
429			while(point_node) {
430			if(point_node->type == XML_ELEMENT_NODE) {
431
432			if(strcasecmp((char*)point_node->name, "point") == 0) {
433			*point = g_new0(track_point_t, 1);
434			(*point)->lpos.x = xml_get_prop_int(point_node, "x");
435			(*point)->lpos.y = xml_get_prop_int(point_node, "y");
436
437			point = &((*point)->next);
438			}
439			}
440			point_node = point_node->next;
441			}
442
443			seg = &((*seg)->next);
444			}
445			}
446			seg_node = seg_node->next;
447			}
448			}
449			}
450			}
451
452			g_free(trk_name);
453
454			printf("restoring track mode %d\n", track->mode);
455			track_set_mode(appdata, track, track->mode);
456			track->saved = TRUE;
457			track_info(track);
458
459			return track;
460			}
461
462			static void track_end_segment(track_t *track) {
463			if(track->cur_seg) {
464			printf("ending a segment\n");
465
466			/* todo: check if segment only has 1 point */
467
468			track->cur_seg = NULL;
469			}
470			}
471
472			static void track_append_position(appdata_t appdata, pos_t pos) {
473			track_t *track = appdata->track.track;
474
475			if(!track->cur_seg) {
476			printf("starting new segment\n");
477
478			track_seg_t **seg = &(track->track_seg);
479			while(seg) seg = &((seg)->next);
480
481			*seg = track->cur_seg = g_new0(track_seg_t, 1);
482			} else
483			printf("appending to current segment\n");
484
485			gint seg_len = 0;
486			track_point_t **point = &(track->cur_seg->track_point);
487			while(point) { seg_len++; point = &((point)->next); }
488
489			/* create utm coordinates */
490			lpos_t lpos;
491			bounds_t *bounds = appdata->osm->bounds;
492			pos2lpos(bounds, pos, &lpos);
493
494			/* check if point is within bounds */
495			if((lpos.x < bounds->min.x) \|\| (lpos.x > bounds->max.x) \|\|
496			(lpos.y < bounds->min.y) \|\| (lpos.y > bounds->max.y)) {
497			printf("position out of bounds\n");
498
499			/* end segment */
500			track_end_segment(track);
501			map_track_pos(appdata, NULL);
502			} else {
503			map_track_pos(appdata, &lpos);
504
505			/* don't append if point is the same as last time */
506			track_point_t *prev = track->cur_seg->track_point;
507			while(prev && prev->next) prev = prev->next;
508
509			if(prev && prev->lpos.x == lpos.x && prev->lpos.y == lpos.y) {
510			printf("same value as last point -> ignore\n");
511			} else {
512
513			*point = g_new0(track_point_t, 1);
514			(*point)->lpos.x = lpos.x;
515			(*point)->lpos.y = lpos.y;
516			track->saved = FALSE;
517
518			/* if segment length was 1 the segment can now be drawn for the first time */
519			if(seg_len <= 1) {
520			printf("initial/second draw with seg_len %d\n", seg_len);
521
522			if(seg_len == 0) g_assert(!track->cur_seg->item);
523			else g_assert(track->cur_seg->item);
524
525			map_track_draw_seg(appdata->map, track->cur_seg);
526			}
527
528			/* if segment length was > 1 the segment has to be updated */
529			if(seg_len > 1) {
530			printf("update draw\n");
531
532			g_assert(track->cur_seg->item);
533			map_track_update_seg(appdata->map, track->cur_seg);
534			}
535			}
536			}
537			}
538
539			static gboolean update(gpointer data) {
540			appdata_t appdata = (appdata_t)data;
541
542			pos_t *pos = gps_get_pos(appdata);
543			if(pos) {
544			printf("valid position %f/%f\n", pos->lat, pos->lon);
545			track_append_position(appdata, pos);
546			} else {
547			printf("no valid position\n");
548			/* end segment */
549			track_end_segment(appdata->track.track);
550			map_track_pos(appdata, NULL);
551			}
552
553			return TRUE;
554			}
555
556			static void track_enable_gps(appdata_t *appdata) {
557			appdata->gps_enabled = TRUE;
558
559			if(!appdata->track.handler_id) {
560			appdata->track.handler_id = gtk_timeout_add(1000, update, appdata);
561
562			if(appdata->track.track) {
563			printf("there's already a track -> restored!!\n");
564			map_track_draw(appdata->map, appdata->track.track);
565			} else
566			appdata->track.track = g_new0(track_t, 1);
567			}
568			}
569
570			static void track_disable_gps(appdata_t *appdata) {
571			appdata->gps_enabled = FALSE;
572
573			if(appdata->track.handler_id) {
574			gtk_timeout_remove(appdata->track.handler_id);
575			appdata->track.handler_id = 0;
576			}
577			}
578
579			void track_do(appdata_t appdata, track_mode_t mode, char name) {
580
581			printf("track do %d\n", mode);
582
583			/* remove existing track */
584			if(appdata->track.track) {
585			track_clear(appdata, appdata->track.track);
586			appdata->track.track = NULL;
587			map_track_pos(appdata, NULL);
588			}
589
590			switch(mode) {
591			case TRACK_NONE:
592			/* disable gps if it was on */
593			track_disable_gps(appdata);
594
595			track_set_mode(appdata, appdata->track.track, TRACK_NONE);
596			break;
597
598			case TRACK_IMPORT:
599			/* disable gps if it was on */
600			track_disable_gps(appdata);
601
602			appdata->track.track = track_import(appdata->osm, name);
603			map_track_draw(appdata->map, appdata->track.track);
604			track_set_mode(appdata, appdata->track.track, TRACK_IMPORT);
605			break;
606
607			case TRACK_GPS:
608			track_enable_gps(appdata);
609
610			track_set_mode(appdata, appdata->track.track, TRACK_GPS);
611			break;
612			}
613			}