trunk/src/diff.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/>.
 */

/*
 * diff.c - generate and restore changes on the current data set
 */

#include "appdata.h"

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

#if !defined(LIBXML_TREE_ENABLED) || !defined(LIBXML_OUTPUT_ENABLED)
#error "libxml doesn't support required tree or output"
#endif

static void diff_save_tags(tag_t *tag, xmlNodePtr node) {
  while(tag) {
    xmlNodePtr tag_node = xmlNewChild(node, NULL, 
                                      BAD_CAST "tag", NULL);
    xmlNewProp(tag_node, BAD_CAST "k", BAD_CAST tag->key);
    xmlNewProp(tag_node, BAD_CAST "v", BAD_CAST tag->value);
    tag = tag->next;
  }
}

static void diff_save_state_n_id(int flags, xmlNodePtr node, item_id_t id) {
  if(flags & OSM_FLAG_DELETED) 
    xmlNewProp(node, BAD_CAST "state", BAD_CAST "deleted");
  else if(flags & OSM_FLAG_NEW) 
    xmlNewProp(node, BAD_CAST "state", BAD_CAST "new");

  /* all items need an id */
  char *id_str = g_strdup_printf("%ld", id);
  xmlNewProp(node, BAD_CAST "id", BAD_CAST id_str);
  g_free(id_str);
}

static void diff_save_nodes(node_t *node, xmlNodePtr root_node) {
  /* store all modfied nodes */
  while(node) {
    if(node->flags) { 
      xmlNodePtr node_node = xmlNewChild(root_node, NULL, 
                                         BAD_CAST "node", NULL);

      diff_save_state_n_id(node->flags, node_node, node->id);

      if(!(node->flags & OSM_FLAG_DELETED)) {
        char str[32];

        /* additional info is only required if the node hasn't been deleted */
        g_ascii_dtostr(str, sizeof(str), node->pos.lat);
        xmlNewProp(node_node, BAD_CAST "lat", BAD_CAST str);
        g_ascii_dtostr(str, sizeof(str), node->pos.lon);
        xmlNewProp(node_node, BAD_CAST "lon", BAD_CAST str);
        snprintf(str, sizeof(str), "%ld", node->time);
        xmlNewProp(node_node, BAD_CAST "time", BAD_CAST str);

        diff_save_tags(node->tag, node_node);
      }
    }
     node = node->next;
  }
}

static void diff_save_ways(way_t *way, xmlNodePtr root_node) {

  /* store all modfied ways */
  while(way) {
    if(way->flags) {
      xmlNodePtr node_way = xmlNewChild(root_node, NULL, 
                                         BAD_CAST "way", NULL);

      diff_save_state_n_id(way->flags, node_way, way->id);
      
      if(way->flags & OSM_FLAG_HIDDEN) 
        xmlNewProp(node_way, BAD_CAST "hidden", BAD_CAST "true");

      /* additional info is only required if the way hasn't been deleted */
      /* and of the dirty or new flags are set. (otherwise e.g. only */
      /* the hidden flag may be set) */
      if((!(way->flags & OSM_FLAG_DELETED)) && 
         (way->flags & (OSM_FLAG_DIRTY | OSM_FLAG_NEW))) {
        node_chain_t *node_chain = way->node_chain;
        while(node_chain) {
          xmlNodePtr node_node = xmlNewChild(node_way, NULL, 
                                             BAD_CAST "nd", NULL);
          char *id = g_strdup_printf("%ld", node_chain->node->id);
          xmlNewProp(node_node, BAD_CAST "ref", BAD_CAST id);
          g_free(id);
          node_chain = node_chain->next;
        }
        diff_save_tags(way->tag, node_way);
      }
    }
    way = way->next;
  }
}

static void diff_save_relations(relation_t *relation, xmlNodePtr root_node) {

  /* store all modfied relations */
  while(relation) {
    if(relation->flags) { 
      xmlNodePtr node_rel = xmlNewChild(root_node, NULL, 
                                         BAD_CAST "relation", NULL);

      diff_save_state_n_id(relation->flags, node_rel, relation->id);
      
      if(!(relation->flags & OSM_FLAG_DELETED)) {
        /* additional info is only required if the relation */
        /* hasn't been deleted */
        member_t *member = relation->member;
        while(member) {
          xmlNodePtr node_member = xmlNewChild(node_rel, NULL, 
                                             BAD_CAST "member", NULL);

          char *ref = NULL;
          switch(member->type) {
          case NODE:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "node");
            ref = g_strdup_printf("%ld", member->node->id);
            break;
          case WAY:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "way");
            ref = g_strdup_printf("%ld", member->way->id);
            break;
          case RELATION:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "relation");
            ref = g_strdup_printf("%ld", member->relation->id);
            break;

            /* XXX_ID's are used if this is a reference to an item not */
            /* stored in this xml data set */
          case NODE_ID:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "node");
            ref = g_strdup_printf("%ld", member->id);
            break;
          case WAY_ID:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "way");
            ref = g_strdup_printf("%ld", member->id);
            break;
          case RELATION_ID:
            xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "relation");
            ref = g_strdup_printf("%ld", member->id);
            break;

          default:
            printf("unexpected member type %d\n", member->type);
            break;
          }

          g_assert(ref);
          xmlNewProp(node_member, BAD_CAST "ref", BAD_CAST ref);
          g_free(ref);

          if(member->role) 
            xmlNewProp(node_member, BAD_CAST "role", BAD_CAST member->role);

          member = member->next;
        }
        diff_save_tags(relation->tag, node_rel);
      }
    }
    relation = relation->next;
  }
}


/* return true if no diff needs to be saved */
gboolean diff_is_clean(osm_t *osm, gboolean honor_hidden_flags) {
  gboolean clean = TRUE;

  /* check if a diff is necessary */
  node_t *node = osm->node;
  while(node && clean) {
    if(node->flags) clean = FALSE;
    node = node->next;
  }

  way_t *way = osm->way;
  while(way && clean) {
    if(honor_hidden_flags) {
      if(way->flags) clean = FALSE;
    } else
      if(way->flags & ~OSM_FLAG_HIDDEN) 
        clean = FALSE;

    way = way->next;
  }

  relation_t *relation = osm->relation;
  while(relation && clean) {
    if(relation->flags) clean = FALSE;
    relation = relation->next;
  }

  return clean;
}

void diff_save(project_t *project, osm_t *osm) {
  if(!project || !osm) return;

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

  if(diff_is_clean(osm, TRUE)) {
    printf("data set is clean, removing diff if present\n");
    g_remove(diff_name);
    g_free(diff_name);
    return;
  }

  printf("data set is dirty, generating diff\n");

  LIBXML_TEST_VERSION;

  xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
  xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "diff");
  xmlNewProp(root_node, BAD_CAST "name", BAD_CAST project->name);
  xmlDocSetRootElement(doc, root_node);

  diff_save_nodes(osm->node, root_node);
  diff_save_ways(osm->way, root_node);
  diff_save_relations(osm->relation, root_node);

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

  g_free(diff_name);
}

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

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

  return value;
}

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

  if(str) {
    if(strcasecmp(str, "new") == 0) {
      xmlFree(str);
      return OSM_FLAG_NEW;
    }

    if(strcasecmp(str, "deleted") == 0) {
      xmlFree(str);
      return OSM_FLAG_DELETED;
    }

    g_assert(0);
  }

  return OSM_FLAG_DIRTY;
}

static pos_t *xml_get_prop_pos(xmlNode *node) {
  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 NULL;
  }

  pos_t *pos = g_new0(pos_t, 1);
  pos->lat = g_ascii_strtod(str_lat, NULL);
  pos->lon = g_ascii_strtod(str_lon, NULL);

  xmlFree(str_lon);
  xmlFree(str_lat);

  return pos;
}

static tag_t *xml_scan_tags(xmlDoc *doc, xmlNodePtr node, osm_t *osm) {
  /* scan for tags */
  tag_t *first_tag = NULL;
  tag_t **tag = &first_tag;

  while(node) {
    if(node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)node->name, "tag") == 0) {
        /* attach tag to node/way */
        *tag = osm_parse_osm_tag(osm, doc, node);
        if(*tag) tag = &((*tag)->next);
      }
    }
    node = node->next;
  }
  return first_tag;
}

void diff_restore_node(xmlDoc *doc, xmlNodePtr node_node, osm_t *osm) {
  printf("Restoring node\n");

  /* read properties */
  item_id_t id = xml_get_prop_int(node_node, "id", ID_ILLEGAL);
  if(id == ID_ILLEGAL) {
    printf("  Node entry missing id\n");
    return;
  }

  int state = xml_get_prop_state(node_node, "state");
  pos_t *pos = xml_get_prop_pos(node_node);

  if(!(state & OSM_FLAG_DELETED) && !pos) {
    printf("  Node not deleted, but no valid position\n");
    return;
  }
    
  /* evaluate properties */
  node_t *node = NULL;

  switch(state) {
  case OSM_FLAG_NEW:
    printf("  Restoring NEW node\n");
    
    node = g_new0(node_t, 1);
    node->visible = TRUE;
    node->flags = OSM_FLAG_NEW;
    node->time = xml_get_prop_int(node_node, "time", 0);
    if(!node->time) node->time = time(NULL);

    /* attach to end of node list */
    node_t **lnode = &osm->node;
    while(*lnode) lnode = &(*lnode)->next;  
    *lnode = node;
    break;

  case OSM_FLAG_DELETED:
    printf("  Restoring DELETE flag\n");
    
    if((node = osm_get_node_by_id(osm, id))) 
      node->flags |= OSM_FLAG_DELETED;      
    else
      printf("  WARNING: no node with that id found\n");
    break;

  case OSM_FLAG_DIRTY:
    printf("  Valid id/position (DIRTY)\n");
    
    if((node = osm_get_node_by_id(osm, id))) 
      node->flags |= OSM_FLAG_DIRTY;
    else
      printf("  WARNING: no node with that id found\n");
    break;

  default:
    printf("  Illegal node entry\n");
    return;
    break;
  }
  
  if(!node) {
    printf("  no valid node\n");                    
    return;
  }

  /* update id and position from diff */
  node->id = id;
  if(pos) {
    node->pos.lat = pos->lat;
    node->pos.lon = pos->lon;
    
    pos2lpos(osm->bounds, &node->pos, &node->lpos);

    g_free(pos);
  }
  
  /* node may be an existing node, so remove tags to */
  /* make space for new ones */
  if(node->tag) {
    printf("  removing existing tags for diff tags\n");
    osm_tag_free(node->tag);
    node->tag = NULL;
  }
  
  node->tag = xml_scan_tags(doc, node_node->children, osm);
}

void diff_restore_way(xmlDoc *doc, xmlNodePtr node_node, osm_t *osm) {
  printf("Restoring way\n");
              
  item_id_t id = xml_get_prop_int(node_node, "id", ID_ILLEGAL);
  if(id == ID_ILLEGAL) {
    printf("  entry missing id\n");
    return;
  }

  int state = xml_get_prop_state(node_node, "state");

  /* handle hidden flag */
  gboolean hidden = FALSE;
  char *str = (char*)xmlGetProp(node_node, BAD_CAST "hidden");
  if(str) { 
    if(strcasecmp(str, "true") == 0) 
      hidden = TRUE;

    xmlFree(str);
  }


  /* evaluate properties */
  way_t *way = NULL;
  switch(state) {
  case OSM_FLAG_NEW:
    printf("  Restoring NEW way\n");
    
    way = g_new0(way_t, 1);
    way->visible = TRUE;
    way->flags = OSM_FLAG_NEW;
    way->time = xml_get_prop_int(node_node, "time", 0);
    if(!way->time) way->time = time(NULL);

    /* attach to end of way list */
    way_t **lway = &osm->way;
    while(*lway) lway = &(*lway)->next;  
    *lway = way;
    break;

  case OSM_FLAG_DELETED:
    printf("  Restoring DELETE flag\n");
    
    if((way = osm_get_way_by_id(osm, id)))
      way->flags |= OSM_FLAG_DELETED;
    else
      printf("  WARNING: no way with that id found\n");
    break;

  case OSM_FLAG_DIRTY:
    printf("  Valid id (DIRTY)\n");

    if((way = osm_get_way_by_id(osm, id))) 
      way->flags |= OSM_FLAG_DIRTY;
    else
      printf("  WARNING: no way with that id found\n");
    break;

  default:
    printf("  Illegal way entry\n");
    return;
  }

  if(!way) {
    printf("  no valid way\n");
    return;
  }
  
  /* update id from diff */
  way->id = id;
    
  /* update node_chain */
  if(hidden)
    way->flags |= OSM_FLAG_HIDDEN;
    
  gboolean installed_new_nodes = FALSE;

  /* scan for nodes */
  node_chain_t **node_chain = &way->node_chain;
  xmlNode *nd_node = NULL;
  for(nd_node = node_node->children; nd_node; nd_node = nd_node->next) {
    if(nd_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)nd_node->name, "nd") == 0) {

        /* only replace the original nodes if new nodes have actually been */
        /* found. */
        if(!installed_new_nodes) {
          /* way may be an existing way, so remove nodes to */
          /* make space for new ones */
          if(way->node_chain) {
            printf("  removing existing nodes for diff nodes\n");
            osm_node_chain_free(way->node_chain);
            way->node_chain = NULL;
          }

          installed_new_nodes = TRUE;
        }

        /* attach node to node_chain */
        *node_chain = osm_parse_osm_way_nd(osm, doc, nd_node);
        if(*node_chain) 
          node_chain = &((*node_chain)->next);
      }
    }
  }

  /* only replace tags if nodes have been found before. if no nodes */
  /* were found this wasn't a dirty entry but e.g. only the hidden */
  /* flag had been set */
  if(installed_new_nodes) {
  
    /* node may be an existing node, so remove tags to */
    /* make space for new ones */
    if(way->tag) {
      printf("  removing existing tags for diff tags\n");
      osm_tag_free(way->tag);
      way->tag = NULL;
    }
    
    way->tag = xml_scan_tags(doc, node_node->children, osm);
  } else {
    printf("  no nodes restored, way isn't dirty!\n");
    way->flags &= ~OSM_FLAG_DIRTY;
  }
}

void diff_restore_relation(xmlDoc *doc, xmlNodePtr node_rel, osm_t *osm) {
  printf("Restoring relation\n");
              
  item_id_t id = xml_get_prop_int(node_rel, "id", ID_ILLEGAL);
  if(id == ID_ILLEGAL) {
    printf("  entry missing id\n");
    return;
  }

  int state = xml_get_prop_state(node_rel, "state");

  /* evaluate properties */
  relation_t *relation = NULL;
  switch(state) {
  case OSM_FLAG_NEW:
    printf("  Restoring NEW relation\n");
    
    relation = g_new0(relation_t, 1);
    relation->visible = TRUE;
    relation->flags = OSM_FLAG_NEW;
    relation->time = xml_get_prop_int(node_rel, "time", 0);
    if(!relation->time) relation->time = time(NULL);

    /* attach to end of relation list */
    relation_t **lrelation = &osm->relation;
    while(*lrelation) lrelation = &(*lrelation)->next;  
    *lrelation = relation;
    break;

  case OSM_FLAG_DELETED:
    printf("  Restoring DELETE flag\n");
    
    if((relation = osm_get_relation_by_id(osm, id)))
      relation->flags |= OSM_FLAG_DELETED;
    else
      printf("  WARNING: no relation with that id found\n");
    break;

  case OSM_FLAG_DIRTY:
    printf("  Valid id (DIRTY)\n");
    
    if((relation = osm_get_relation_by_id(osm, id))) 
      relation->flags |= OSM_FLAG_DIRTY;
    else
      printf("  WARNING: no relation with that id found\n");
    break;

  default:
    printf("  Illegal relation entry\n");
    return;
  }

  if(!relation) {
    printf("  no valid relation\n");
    return;
  }
  
  /* update id from diff */
  relation->id = id;
    
  /* update members */
    
  /* this may be an existing relation, so remove members to */
  /* make space for new ones */
  if(relation->member) {
    printf("  removing existing members for diff members\n");
    osm_members_free(relation->member);
    relation->member = NULL;
  }

  /* scan for members */
  member_t **member = &relation->member;
  xmlNode *member_node = NULL;
  for(member_node = node_rel->children; member_node; 
      member_node = member_node->next) {
    if(member_node->type == XML_ELEMENT_NODE) {
      if(strcasecmp((char*)member_node->name, "member") == 0) {
        /* attach member to member_chain */
        *member = osm_parse_osm_relation_member(osm, doc, member_node);
        if(*member) 
          member = &((*member)->next);
      }
    }
  }
  
  /* node may be an existing node, so remove tags to */
  /* make space for new ones */
  if(relation->tag) {
    printf("  removing existing tags for diff tags\n");
    osm_tag_free(relation->tag);
    relation->tag = NULL;
  }
  
  relation->tag = xml_scan_tags(doc, node_rel->children, osm);
}

void diff_restore(appdata_t *appdata, project_t *project, osm_t *osm) {
  if(!project || !osm) return;

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

  if(!g_file_test(diff_name, G_FILE_TEST_EXISTS)) {
    printf("no diff present!\n");
    g_free(diff_name);
    return;
  }
  
  printf("diff found, applying ...\n");
  
  xmlDoc *doc = NULL;
  xmlNode *root_element = NULL;
  
  /* parse the file and get the DOM */
  if((doc = xmlReadFile(diff_name, NULL, 0)) == NULL) {
    errorf(GTK_WIDGET(appdata->window), 
           "Error: could not parse file %s\n", diff_name);
    g_free(diff_name);
    return;
  }
  
  /* 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, "diff") == 0) {
        char *str = (char*)xmlGetProp(cur_node, BAD_CAST "name");
        if(str) {
          printf("diff for project %s\n", str);
          if(strcmp(project->name, str) != 0) {
            messagef(GTK_WIDGET(appdata->window), _("Warning"), 
                     "Diff name (%s) does not match project name (%s)",
                     str, project->name);
          }
          xmlFree(str);
        }

        xmlNodePtr node_node = cur_node->children;
        while(node_node) {
          if(node_node->type == XML_ELEMENT_NODE) {

            if(strcasecmp((char*)node_node->name, "node") == 0) 
              diff_restore_node(doc, node_node, osm);
            
            else if(strcasecmp((char*)node_node->name, "way") == 0) 
              diff_restore_way(doc, node_node, osm);

            else if(strcasecmp((char*)node_node->name, "relation") == 0) 
              diff_restore_relation(doc, node_node, osm);

            else 
              printf("WARNING: item %s not restored\n", node_node->name);
          }
          node_node = node_node->next;
        }
      }
    }
  }
 
  g_free(diff_name);

  xmlFreeDoc(doc);
  xmlCleanupParser();

  /* check for hidden ways and update menu accordingly */
  gboolean something_is_hidden = FALSE;
  way_t *way = osm->way;
  while(!something_is_hidden && way) {
    if(way->flags & OSM_FLAG_HIDDEN)
      something_is_hidden = TRUE;

    way = way->next;
  }

  if(something_is_hidden) {
    printf("hidden flags have been restored, enable show_add menu\n");

    statusbar_set(appdata, _("Some objects have been hidden"), TRUE);
    gtk_widget_set_sensitive(appdata->menu_item_map_show_all, TRUE);
  }
}
  
gboolean diff_present(project_t *project) {
  char *diff_name = g_strdup_printf("%s/%s.diff", project->path, project->name);
  
  if(!g_file_test(diff_name, G_FILE_TEST_EXISTS)) {
    printf("no diff present!\n");
    g_free(diff_name);
    return FALSE;
  }
  
  g_free(diff_name);
  return TRUE;
}

void diff_remove(project_t *project) {
  char *diff_name = g_strdup_printf("%s/%s.diff", project->path, project->name);
  g_remove(diff_name);
  g_free(diff_name);
}
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			/*
21			* diff.c - generate and restore changes on the current data set
22			*/
23
24			#include "appdata.h"
25
26			#include <libxml/parser.h>
27			#include <libxml/tree.h>
28
29			#if !defined(LIBXML_TREE_ENABLED) \|\| !defined(LIBXML_OUTPUT_ENABLED)
30			#error "libxml doesn't support required tree or output"
31			#endif
32
33			static void diff_save_tags(tag_t *tag, xmlNodePtr node) {
34			while(tag) {
35			xmlNodePtr tag_node = xmlNewChild(node, NULL,
36			BAD_CAST "tag", NULL);
37			xmlNewProp(tag_node, BAD_CAST "k", BAD_CAST tag->key);
38			xmlNewProp(tag_node, BAD_CAST "v", BAD_CAST tag->value);
39			tag = tag->next;
40			}
41			}
42
43			static void diff_save_state_n_id(int flags, xmlNodePtr node, item_id_t id) {
44			if(flags & OSM_FLAG_DELETED)
45			xmlNewProp(node, BAD_CAST "state", BAD_CAST "deleted");
46			else if(flags & OSM_FLAG_NEW)
47			xmlNewProp(node, BAD_CAST "state", BAD_CAST "new");
48
49			/* all items need an id */
50			char *id_str = g_strdup_printf("%ld", id);
51			xmlNewProp(node, BAD_CAST "id", BAD_CAST id_str);
52			g_free(id_str);
53			}
54
55			static void diff_save_nodes(node_t *node, xmlNodePtr root_node) {
56			/* store all modfied nodes */
57			while(node) {
58			if(node->flags) {
59			xmlNodePtr node_node = xmlNewChild(root_node, NULL,
60			BAD_CAST "node", NULL);
61
62			diff_save_state_n_id(node->flags, node_node, node->id);
63
64			if(!(node->flags & OSM_FLAG_DELETED)) {
65			char str[32];
66
67			/* additional info is only required if the node hasn't been deleted */
68			g_ascii_dtostr(str, sizeof(str), node->pos.lat);
69			xmlNewProp(node_node, BAD_CAST "lat", BAD_CAST str);
70			g_ascii_dtostr(str, sizeof(str), node->pos.lon);
71			xmlNewProp(node_node, BAD_CAST "lon", BAD_CAST str);
72			snprintf(str, sizeof(str), "%ld", node->time);
73			xmlNewProp(node_node, BAD_CAST "time", BAD_CAST str);
74
75			diff_save_tags(node->tag, node_node);
76			}
77			}
78			node = node->next;
79			}
80			}
81
82			static void diff_save_ways(way_t *way, xmlNodePtr root_node) {
83
84			/* store all modfied ways */
85			while(way) {
86			if(way->flags) {
87			xmlNodePtr node_way = xmlNewChild(root_node, NULL,
88			BAD_CAST "way", NULL);
89
90			diff_save_state_n_id(way->flags, node_way, way->id);
91
92			if(way->flags & OSM_FLAG_HIDDEN)
93			xmlNewProp(node_way, BAD_CAST "hidden", BAD_CAST "true");
94
95			/* additional info is only required if the way hasn't been deleted */
96			/* and of the dirty or new flags are set. (otherwise e.g. only */
97			/* the hidden flag may be set) */
98			if((!(way->flags & OSM_FLAG_DELETED)) &&
99			(way->flags & (OSM_FLAG_DIRTY \| OSM_FLAG_NEW))) {
100			node_chain_t *node_chain = way->node_chain;
101			while(node_chain) {
102			xmlNodePtr node_node = xmlNewChild(node_way, NULL,
103			BAD_CAST "nd", NULL);
104			char *id = g_strdup_printf("%ld", node_chain->node->id);
105			xmlNewProp(node_node, BAD_CAST "ref", BAD_CAST id);
106			g_free(id);
107			node_chain = node_chain->next;
108			}
109			diff_save_tags(way->tag, node_way);
110			}
111			}
112			way = way->next;
113			}
114			}
115
116			static void diff_save_relations(relation_t *relation, xmlNodePtr root_node) {
117
118			/* store all modfied relations */
119			while(relation) {
120			if(relation->flags) {
121			xmlNodePtr node_rel = xmlNewChild(root_node, NULL,
122			BAD_CAST "relation", NULL);
123
124			diff_save_state_n_id(relation->flags, node_rel, relation->id);
125
126			if(!(relation->flags & OSM_FLAG_DELETED)) {
127			/* additional info is only required if the relation */
128			/* hasn't been deleted */
129			member_t *member = relation->member;
130			while(member) {
131			xmlNodePtr node_member = xmlNewChild(node_rel, NULL,
132			BAD_CAST "member", NULL);
133
134			char *ref = NULL;
135			switch(member->type) {
136			case NODE:
137			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "node");
138			ref = g_strdup_printf("%ld", member->node->id);
139			break;
140			case WAY:
141			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "way");
142			ref = g_strdup_printf("%ld", member->way->id);
143			break;
144			case RELATION:
145			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "relation");
146			ref = g_strdup_printf("%ld", member->relation->id);
147			break;
148
149			/* XXX_ID's are used if this is a reference to an item not */
150			/* stored in this xml data set */
151			case NODE_ID:
152			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "node");
153			ref = g_strdup_printf("%ld", member->id);
154			break;
155			case WAY_ID:
156			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "way");
157			ref = g_strdup_printf("%ld", member->id);
158			break;
159			case RELATION_ID:
160			xmlNewProp(node_member, BAD_CAST "type", BAD_CAST "relation");
161			ref = g_strdup_printf("%ld", member->id);
162			break;
163
164			default:
165			printf("unexpected member type %d\n", member->type);
166			break;
167			}
168
169			g_assert(ref);
170			xmlNewProp(node_member, BAD_CAST "ref", BAD_CAST ref);
171			g_free(ref);
172
173			if(member->role)
174			xmlNewProp(node_member, BAD_CAST "role", BAD_CAST member->role);
175
176			member = member->next;
177			}
178			diff_save_tags(relation->tag, node_rel);
179			}
180			}
181			relation = relation->next;
182			}
183			}
184
185
186			/* return true if no diff needs to be saved */
187			gboolean diff_is_clean(osm_t *osm, gboolean honor_hidden_flags) {
188			gboolean clean = TRUE;
189
190			/* check if a diff is necessary */
191			node_t *node = osm->node;
192			while(node && clean) {
193			if(node->flags) clean = FALSE;
194			node = node->next;
195			}
196
197			way_t *way = osm->way;
198			while(way && clean) {
199			if(honor_hidden_flags) {
200			if(way->flags) clean = FALSE;
201			} else
202			if(way->flags & ~OSM_FLAG_HIDDEN)
203			clean = FALSE;
204
205			way = way->next;
206			}
207
208			relation_t *relation = osm->relation;
209			while(relation && clean) {
210			if(relation->flags) clean = FALSE;
211			relation = relation->next;
212			}
213
214			return clean;
215			}
216
217			void diff_save(project_t project, osm_t osm) {
218	harbaum	4	if(!project \|\| !osm) return;
219	harbaum	1
220			char *diff_name =
221			g_strdup_printf("%s/%s.diff", project->path, project->name);
222
223			if(diff_is_clean(osm, TRUE)) {
224			printf("data set is clean, removing diff if present\n");
225			g_remove(diff_name);
226			g_free(diff_name);
227			return;
228			}
229
230			printf("data set is dirty, generating diff\n");
231
232			LIBXML_TEST_VERSION;
233
234			xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
235			xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "diff");
236			xmlNewProp(root_node, BAD_CAST "name", BAD_CAST project->name);
237			xmlDocSetRootElement(doc, root_node);
238
239			diff_save_nodes(osm->node, root_node);
240			diff_save_ways(osm->way, root_node);
241			diff_save_relations(osm->relation, root_node);
242
243			xmlSaveFormatFileEnc(diff_name, doc, "UTF-8", 1);
244			xmlFreeDoc(doc);
245			xmlCleanupParser();
246
247			g_free(diff_name);
248			}
249
250			static int xml_get_prop_int(xmlNode node, char prop, int def) {
251			char str = (char)xmlGetProp(node, BAD_CAST prop);
252			int value = def;
253
254			if(str) {
255			value = strtoul(str, NULL, 10);
256			xmlFree(str);
257			}
258
259			return value;
260			}
261
262			static int xml_get_prop_state(xmlNode node, char prop) {
263			char str = (char)xmlGetProp(node, BAD_CAST prop);
264
265			if(str) {
266			if(strcasecmp(str, "new") == 0) {
267			xmlFree(str);
268			return OSM_FLAG_NEW;
269			}
270
271			if(strcasecmp(str, "deleted") == 0) {
272			xmlFree(str);
273			return OSM_FLAG_DELETED;
274			}
275
276			g_assert(0);
277			}
278
279			return OSM_FLAG_DIRTY;
280			}
281
282			static pos_t xml_get_prop_pos(xmlNode node) {
283			char str_lat = (char)xmlGetProp(node, BAD_CAST "lat");
284			char str_lon = (char)xmlGetProp(node, BAD_CAST "lon");
285
286			if(!str_lon \|\| !str_lat) {
287			if(!str_lon) xmlFree(str_lon);
288			if(!str_lat) xmlFree(str_lat);
289			return NULL;
290			}
291
292			pos_t *pos = g_new0(pos_t, 1);
293			pos->lat = g_ascii_strtod(str_lat, NULL);
294			pos->lon = g_ascii_strtod(str_lon, NULL);
295
296			xmlFree(str_lon);
297			xmlFree(str_lat);
298
299			return pos;
300			}
301
302			static tag_t xml_scan_tags(xmlDoc doc, xmlNodePtr node, osm_t *osm) {
303			/* scan for tags */
304			tag_t *first_tag = NULL;
305			tag_t **tag = &first_tag;
306
307			while(node) {
308			if(node->type == XML_ELEMENT_NODE) {
309			if(strcasecmp((char*)node->name, "tag") == 0) {
310			/* attach tag to node/way */
311			*tag = osm_parse_osm_tag(osm, doc, node);
312			if(tag) tag = &((tag)->next);
313			}
314			}
315			node = node->next;
316			}
317			return first_tag;
318			}
319
320			void diff_restore_node(xmlDoc doc, xmlNodePtr node_node, osm_t osm) {
321			printf("Restoring node\n");
322
323			/* read properties */
324			item_id_t id = xml_get_prop_int(node_node, "id", ID_ILLEGAL);
325			if(id == ID_ILLEGAL) {
326			printf(" Node entry missing id\n");
327			return;
328			}
329
330			int state = xml_get_prop_state(node_node, "state");
331			pos_t *pos = xml_get_prop_pos(node_node);
332
333			if(!(state & OSM_FLAG_DELETED) && !pos) {
334			printf(" Node not deleted, but no valid position\n");
335			return;
336			}
337
338			/* evaluate properties */
339			node_t *node = NULL;
340
341			switch(state) {
342			case OSM_FLAG_NEW:
343			printf(" Restoring NEW node\n");
344
345			node = g_new0(node_t, 1);
346			node->visible = TRUE;
347			node->flags = OSM_FLAG_NEW;
348			node->time = xml_get_prop_int(node_node, "time", 0);
349			if(!node->time) node->time = time(NULL);
350
351			/* attach to end of node list */
352			node_t **lnode = &osm->node;
353			while(lnode) lnode = &(lnode)->next;
354			*lnode = node;
355			break;
356
357			case OSM_FLAG_DELETED:
358			printf(" Restoring DELETE flag\n");
359
360			if((node = osm_get_node_by_id(osm, id)))
361			node->flags \|= OSM_FLAG_DELETED;
362			else
363			printf(" WARNING: no node with that id found\n");
364			break;
365
366			case OSM_FLAG_DIRTY:
367			printf(" Valid id/position (DIRTY)\n");
368
369			if((node = osm_get_node_by_id(osm, id)))
370			node->flags \|= OSM_FLAG_DIRTY;
371			else
372			printf(" WARNING: no node with that id found\n");
373			break;
374
375			default:
376			printf(" Illegal node entry\n");
377			return;
378			break;
379			}
380
381			if(!node) {
382			printf(" no valid node\n");
383			return;
384			}
385
386			/* update id and position from diff */
387			node->id = id;
388			if(pos) {
389			node->pos.lat = pos->lat;
390			node->pos.lon = pos->lon;
391
392			pos2lpos(osm->bounds, &node->pos, &node->lpos);
393
394			g_free(pos);
395			}
396
397			/* node may be an existing node, so remove tags to */
398			/* make space for new ones */
399			if(node->tag) {
400			printf(" removing existing tags for diff tags\n");
401			osm_tag_free(node->tag);
402			node->tag = NULL;
403			}
404
405			node->tag = xml_scan_tags(doc, node_node->children, osm);
406			}
407
408			void diff_restore_way(xmlDoc doc, xmlNodePtr node_node, osm_t osm) {
409			printf("Restoring way\n");
410
411			item_id_t id = xml_get_prop_int(node_node, "id", ID_ILLEGAL);
412			if(id == ID_ILLEGAL) {
413			printf(" entry missing id\n");
414			return;
415			}
416
417			int state = xml_get_prop_state(node_node, "state");
418
419			/* handle hidden flag */
420			gboolean hidden = FALSE;
421			char str = (char)xmlGetProp(node_node, BAD_CAST "hidden");
422			if(str) {
423			if(strcasecmp(str, "true") == 0)
424			hidden = TRUE;
425
426			xmlFree(str);
427			}
428
429
430			/* evaluate properties */
431			way_t *way = NULL;
432			switch(state) {
433			case OSM_FLAG_NEW:
434			printf(" Restoring NEW way\n");
435
436			way = g_new0(way_t, 1);
437			way->visible = TRUE;
438			way->flags = OSM_FLAG_NEW;
439			way->time = xml_get_prop_int(node_node, "time", 0);
440			if(!way->time) way->time = time(NULL);
441
442			/* attach to end of way list */
443			way_t **lway = &osm->way;
444			while(lway) lway = &(lway)->next;
445			*lway = way;
446			break;
447
448			case OSM_FLAG_DELETED:
449			printf(" Restoring DELETE flag\n");
450
451			if((way = osm_get_way_by_id(osm, id)))
452			way->flags \|= OSM_FLAG_DELETED;
453			else
454			printf(" WARNING: no way with that id found\n");
455			break;
456
457			case OSM_FLAG_DIRTY:
458			printf(" Valid id (DIRTY)\n");
459
460			if((way = osm_get_way_by_id(osm, id)))
461			way->flags \|= OSM_FLAG_DIRTY;
462			else
463			printf(" WARNING: no way with that id found\n");
464			break;
465
466			default:
467			printf(" Illegal way entry\n");
468			return;
469			}
470
471			if(!way) {
472			printf(" no valid way\n");
473			return;
474			}
475
476			/* update id from diff */
477			way->id = id;
478
479			/* update node_chain */
480			if(hidden)
481			way->flags \|= OSM_FLAG_HIDDEN;
482
483			gboolean installed_new_nodes = FALSE;
484
485			/* scan for nodes */
486			node_chain_t **node_chain = &way->node_chain;
487			xmlNode *nd_node = NULL;
488			for(nd_node = node_node->children; nd_node; nd_node = nd_node->next) {
489			if(nd_node->type == XML_ELEMENT_NODE) {
490			if(strcasecmp((char*)nd_node->name, "nd") == 0) {
491
492			/* only replace the original nodes if new nodes have actually been */
493			/* found. */
494			if(!installed_new_nodes) {
495			/* way may be an existing way, so remove nodes to */
496			/* make space for new ones */
497			if(way->node_chain) {
498			printf(" removing existing nodes for diff nodes\n");
499			osm_node_chain_free(way->node_chain);
500			way->node_chain = NULL;
501			}
502
503			installed_new_nodes = TRUE;
504			}
505
506			/* attach node to node_chain */
507			*node_chain = osm_parse_osm_way_nd(osm, doc, nd_node);
508			if(*node_chain)
509			node_chain = &((*node_chain)->next);
510			}
511			}
512			}
513
514			/* only replace tags if nodes have been found before. if no nodes */
515			/* were found this wasn't a dirty entry but e.g. only the hidden */
516			/* flag had been set */
517			if(installed_new_nodes) {
518
519			/* node may be an existing node, so remove tags to */
520			/* make space for new ones */
521			if(way->tag) {
522			printf(" removing existing tags for diff tags\n");
523			osm_tag_free(way->tag);
524			way->tag = NULL;
525			}
526
527			way->tag = xml_scan_tags(doc, node_node->children, osm);
528			} else {
529			printf(" no nodes restored, way isn't dirty!\n");
530			way->flags &= ~OSM_FLAG_DIRTY;
531			}
532			}
533
534			void diff_restore_relation(xmlDoc doc, xmlNodePtr node_rel, osm_t osm) {
535			printf("Restoring relation\n");
536
537			item_id_t id = xml_get_prop_int(node_rel, "id", ID_ILLEGAL);
538			if(id == ID_ILLEGAL) {
539			printf(" entry missing id\n");
540			return;
541			}
542
543			int state = xml_get_prop_state(node_rel, "state");
544
545			/* evaluate properties */
546			relation_t *relation = NULL;
547			switch(state) {
548			case OSM_FLAG_NEW:
549			printf(" Restoring NEW relation\n");
550
551			relation = g_new0(relation_t, 1);
552			relation->visible = TRUE;
553			relation->flags = OSM_FLAG_NEW;
554			relation->time = xml_get_prop_int(node_rel, "time", 0);
555			if(!relation->time) relation->time = time(NULL);
556
557			/* attach to end of relation list */
558			relation_t **lrelation = &osm->relation;
559			while(lrelation) lrelation = &(lrelation)->next;
560			*lrelation = relation;
561			break;
562
563			case OSM_FLAG_DELETED:
564			printf(" Restoring DELETE flag\n");
565
566			if((relation = osm_get_relation_by_id(osm, id)))
567			relation->flags \|= OSM_FLAG_DELETED;
568			else
569			printf(" WARNING: no relation with that id found\n");
570			break;
571
572			case OSM_FLAG_DIRTY:
573			printf(" Valid id (DIRTY)\n");
574
575			if((relation = osm_get_relation_by_id(osm, id)))
576			relation->flags \|= OSM_FLAG_DIRTY;
577			else
578			printf(" WARNING: no relation with that id found\n");
579			break;
580
581			default:
582			printf(" Illegal relation entry\n");
583			return;
584			}
585
586			if(!relation) {
587			printf(" no valid relation\n");
588			return;
589			}
590
591			/* update id from diff */
592			relation->id = id;
593
594			/* update members */
595
596			/* this may be an existing relation, so remove members to */
597			/* make space for new ones */
598			if(relation->member) {
599			printf(" removing existing members for diff members\n");
600			osm_members_free(relation->member);
601			relation->member = NULL;
602			}
603
604			/* scan for members */
605			member_t **member = &relation->member;
606			xmlNode *member_node = NULL;
607			for(member_node = node_rel->children; member_node;
608			member_node = member_node->next) {
609			if(member_node->type == XML_ELEMENT_NODE) {
610			if(strcasecmp((char*)member_node->name, "member") == 0) {
611			/* attach member to member_chain */
612			*member = osm_parse_osm_relation_member(osm, doc, member_node);
613			if(*member)
614			member = &((*member)->next);
615			}
616			}
617			}
618
619			/* node may be an existing node, so remove tags to */
620			/* make space for new ones */
621			if(relation->tag) {
622			printf(" removing existing tags for diff tags\n");
623			osm_tag_free(relation->tag);
624			relation->tag = NULL;
625			}
626
627			relation->tag = xml_scan_tags(doc, node_rel->children, osm);
628			}
629
630			void diff_restore(appdata_t appdata, project_t project, osm_t *osm) {
631	harbaum	4	if(!project \|\| !osm) return;
632
633	harbaum	1	char *diff_name = g_strdup_printf("%s/%s.diff", project->path, project->name);
634	harbaum	4
635	harbaum	1	if(!g_file_test(diff_name, G_FILE_TEST_EXISTS)) {
636			printf("no diff present!\n");
637			g_free(diff_name);
638			return;
639			}
640
641			printf("diff found, applying ...\n");
642
643			xmlDoc *doc = NULL;
644			xmlNode *root_element = NULL;
645
646			/* parse the file and get the DOM */
647			if((doc = xmlReadFile(diff_name, NULL, 0)) == NULL) {
648			errorf(GTK_WIDGET(appdata->window),
649			"Error: could not parse file %s\n", diff_name);
650			g_free(diff_name);
651			return;
652			}
653
654			/* Get the root element node */
655			root_element = xmlDocGetRootElement(doc);
656
657			xmlNode *cur_node = NULL;
658			for (cur_node = root_element; cur_node; cur_node = cur_node->next) {
659			if (cur_node->type == XML_ELEMENT_NODE) {
660			if(strcasecmp((char*)cur_node->name, "diff") == 0) {
661			char str = (char)xmlGetProp(cur_node, BAD_CAST "name");
662			if(str) {
663			printf("diff for project %s\n", str);
664			if(strcmp(project->name, str) != 0) {
665			messagef(GTK_WIDGET(appdata->window), _("Warning"),
666			"Diff name (%s) does not match project name (%s)",
667			str, project->name);
668			}
669			xmlFree(str);
670			}
671
672			xmlNodePtr node_node = cur_node->children;
673			while(node_node) {
674			if(node_node->type == XML_ELEMENT_NODE) {
675
676			if(strcasecmp((char*)node_node->name, "node") == 0)
677			diff_restore_node(doc, node_node, osm);
678
679			else if(strcasecmp((char*)node_node->name, "way") == 0)
680			diff_restore_way(doc, node_node, osm);
681
682			else if(strcasecmp((char*)node_node->name, "relation") == 0)
683			diff_restore_relation(doc, node_node, osm);
684
685			else
686			printf("WARNING: item %s not restored\n", node_node->name);
687			}
688			node_node = node_node->next;
689			}
690			}
691			}
692			}
693
694			g_free(diff_name);
695
696			xmlFreeDoc(doc);
697			xmlCleanupParser();
698
699			/* check for hidden ways and update menu accordingly */
700			gboolean something_is_hidden = FALSE;
701			way_t *way = osm->way;
702			while(!something_is_hidden && way) {
703			if(way->flags & OSM_FLAG_HIDDEN)
704			something_is_hidden = TRUE;
705
706			way = way->next;
707			}
708
709			if(something_is_hidden) {
710			printf("hidden flags have been restored, enable show_add menu\n");
711
712			statusbar_set(appdata, _("Some objects have been hidden"), TRUE);
713			gtk_widget_set_sensitive(appdata->menu_item_map_show_all, TRUE);
714			}
715			}
716
717			gboolean diff_present(project_t *project) {
718			char *diff_name = g_strdup_printf("%s/%s.diff", project->path, project->name);
719
720			if(!g_file_test(diff_name, G_FILE_TEST_EXISTS)) {
721			printf("no diff present!\n");
722			g_free(diff_name);
723			return FALSE;
724			}
725
726			g_free(diff_name);
727			return TRUE;
728			}
729
730			void diff_remove(project_t *project) {
731			char *diff_name = g_strdup_printf("%s/%s.diff", project->path, project->name);
732			g_remove(diff_name);
733			g_free(diff_name);
734			}