[osm2go] Diff of /trunk/src/map.c

Diff of /trunk/src/map.c

Parent Directory | Revision Log | View Patch Patch

-revision 13 by achadwick,
Mon Dec 15 14:17:29 2008 UTC
+revision 234 by harbaum,
Mon Jul 20 20:15:10 2009 UTC
 Line 30 
 static void map_statusbar(map_t *map, ma
    tag_t *tag = NULL;
    char *str = NULL;
-   switch(map_item->type) {
+   switch(map_item->object.type) {
-   case MAP_TYPE_NODE:
+   case NODE:
      item_str = "Node";
-     id = map_item->node->id;
+     id = map_item->object.node->id;
-     tag = map_item->node->tag;
+     tag = map_item->object.node->tag;
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
      item_str = "Way";
-     id = map_item->way->id;
+     id = map_item->object.way->id;
-     tag = map_item->way->tag;
+     tag = map_item->object.way->tag;
+     break;
+   case RELATION:
+     item_str = "Relation";
+     id = map_item->object.relation->id;
+     tag = map_item->object.relation->tag;
      break;
    default:
-Line 49 
 static void map_statusbar(map_t *map, ma
+Line 55 
 static void map_statusbar(map_t *map, ma
    gboolean collision = FALSE;
    tag_t *tags = tag;
+   while(tag) {
-   if(id == ID_ILLEGAL)
+     if(!collision && info_tag_key_collision(tags, tag))
-     str = g_strdup_printf(_("Unknown item"));
+       collision = TRUE;
-   else {
+     tag = tag->next;
-     str = g_strdup_printf("%s #%ld", item_str, id);
-     /* add some tags ... */
-     while(tag) {
-       if(!collision && info_tag_key_collision(tags, tag))
-         collision = TRUE;
-       /* we don't have much space, so ignore created_by tag */
-       if(!osm_is_creator_tag(tag)) {
-         char *old = str;
-         str = g_strdup_printf("%s, %s=%s", old, tag->key, tag->value);
-         g_free(old);
-       }
-       tag = tag->next;
-     }
    }
+   str = osm_object_get_speaking_name(&map_item->object);
    statusbar_set(map->appdata, str, collision);
    g_free(str);
  }
-Line 123 
 static void map_node_select(appdata_t *a
+Line 115 
 static void map_node_select(appdata_t *a
    g_assert(!map->highlight);
-   map_item->type      = MAP_TYPE_NODE;
+   map_item->object.type      = NODE;
-   map_item->node      = node;
+   map_item->object.node      = node;
    map_item->highlight = FALSE;
    /* node may not have any visible representation at all */
-Line 137 
 static void map_node_select(appdata_t *a
+Line 129 
 static void map_node_select(appdata_t *a
    icon_bar_map_item_selected(appdata, map_item, TRUE);
    /* highlight node */
-   gint x = map_item->node->lpos.x, y = map_item->node->lpos.y;
+   gint x = map_item->object.node->lpos.x, y = map_item->object.node->lpos.y;
    /* create a copy of this map item and mark it as being a highlight */
    map_item_t *new_map_item = g_new0(map_item_t, 1);
-Line 146 
 static void map_node_select(appdata_t *a
+Line 138 
 static void map_node_select(appdata_t *a
    float radius = map->style->highlight.width + map->style->node.radius;
    if(!node->ways) radius += map->style->node.border_radius;
-   if(node->icon_buf && map->style->icon.enable) {
+   if(node->icon_buf && map->style->icon.enable &&
-     gint w = gdk_pixbuf_get_width(map_item->node->icon_buf);
+      !appdata->settings->no_icons) {
-     gint h = gdk_pixbuf_get_height(map_item->node->icon_buf);
+     gint w = gdk_pixbuf_get_width(map_item->object.node->icon_buf);
+     gint h = gdk_pixbuf_get_height(map_item->object.node->icon_buf);
      /* icons are technically square, so a radius slightly bigger */
      /* than sqrt(2)*MAX(w,h) should fit nicely */
-     radius =  0.75 * map->style->icon.scale * ((w>h)?w:h);
+     radius = 0.75 * map->style->icon.scale * ((w>h)?w:h);
    }
+   radius *= map->state->detail;
    map_hl_circle_new(map, CANVAS_GROUP_NODES_HL, new_map_item,
                      x, y, radius, map->style->highlight.color);
    if(!map_item->item) {
      /* and draw a fake node */
      new_map_item = g_new0(map_item_t, 1);
      memcpy(new_map_item, map_item, sizeof(map_item_t));
      new_map_item->highlight = TRUE;
-     map_hl_circle_new(map, CANVAS_GROUP_NODES_HL, new_map_item,
+     map_hl_circle_new(map, CANVAS_GROUP_NODES_IHL, new_map_item,
                        x, y, map->style->node.radius,
                        map->style->highlight.node_color);
    }
-Line 174 
 void map_way_select(appdata_t *appdata,
+Line 168 
 void map_way_select(appdata_t *appdata,
    g_assert(!map->highlight);
-   map_item->type      = MAP_TYPE_WAY;
+   map_item->object.type      = WAY;
-   map_item->way       = way;
+   map_item->object.way       = way;
    map_item->highlight = FALSE;
    map_item->item      = way->map_item_chain->map_item->item;
    map_statusbar(map, map_item);
    icon_bar_map_item_selected(appdata, map_item, TRUE);
    gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, TRUE);
-   gint arrow_width = (map_item->way->draw.flags & OSM_DRAW_FLAG_BG)?
-     map->style->highlight.width + map_item->way->draw.bg.width/2:
-     map->style->highlight.width + map_item->way->draw.width/2;
-   node_chain_t *node_chain = map_item->way->node_chain;
+   gint arrow_width = ((map_item->object.way->draw.flags & OSM_DRAW_FLAG_BG)?
+                       map->style->highlight.width + map_item->object.way->draw.bg.width/2:
+                       map->style->highlight.width + map_item->object.way->draw.width/2)
+     * map->state->detail;
+   node_chain_t *node_chain = map_item->object.way->node_chain;
    node_t *last = NULL;
    while(node_chain) {
      map_item_t item;
-     item.type = MAP_TYPE_NODE;
+     item.object.type = NODE;
-     item.node = node_chain->node;
+     item.object.node = node_chain->node;
      /* draw an arrow between every two nodes */
      if(last) {
        /* create a new map item for every arrow */
        map_item_t *new_map_item = g_new0(map_item_t, 1);
-       new_map_item->type = MAP_TYPE_WAY;
+       new_map_item->object.type = WAY;
-       new_map_item->way = way;
+       new_map_item->object.way = way;
        new_map_item->highlight = TRUE;
        struct { float x, y;} center, diff;
-Line 208 
 void map_way_select(appdata_t *appdata,
+Line 203 
 void map_way_select(appdata_t *appdata,
        diff.x = node_chain->node->lpos.x - last->lpos.x;
        diff.y = node_chain->node->lpos.y - last->lpos.y;
+       /* only draw arrow if there's sufficient space */
+       /* TODO: what if there's not enough space anywhere? */
        float len = sqrt(pow(diff.x, 2)+pow(diff.y, 2));
        if(len > map->style->highlight.arrow_limit*arrow_width) {
          len /= arrow_width;
-Line 222 
 void map_way_select(appdata_t *appdata,
+Line 219 
 void map_way_select(appdata_t *appdata,
          points->coords[2*2+0] = center.x - diff.y - diff.x;
          points->coords[2*2+1] = center.y + diff.x - diff.y;
-         map_hl_polygon_new(map, CANVAS_GROUP_NODES_HL, new_map_item,
+         map_hl_polygon_new(map, CANVAS_GROUP_WAYS_DIR, new_map_item,
                             points, map->style->highlight.arrow_color);
          canvas_points_free(points);
-Line 233 
 void map_way_select(appdata_t *appdata,
+Line 230 
 void map_way_select(appdata_t *appdata,
        /* create a new map item for every node */
        map_item_t *new_map_item = g_new0(map_item_t, 1);
-       new_map_item->type = MAP_TYPE_NODE;
+       new_map_item->object.type = NODE;
-       new_map_item->node = node_chain->node;
+       new_map_item->object.node = node_chain->node;
        new_map_item->highlight = TRUE;
        gint x = node_chain->node->lpos.x;
        gint y = node_chain->node->lpos.y;
-       map_hl_circle_new(map, CANVAS_GROUP_NODES_HL, new_map_item,
+       map_hl_circle_new(map, CANVAS_GROUP_NODES_IHL, new_map_item,
-                         x, y, map->style->node.radius,
+                         x, y, map->style->node.radius * map->state->detail,
                          map->style->highlight.node_color);
      }
-Line 257 
 void map_way_select(appdata_t *appdata,
+Line 254 
 void map_way_select(appdata_t *appdata,
      canvas_points_t *points = canvas_points_new(nodes);
      int node = 0;
-     node_chain = map_item->way->node_chain;
+     node_chain = map_item->object.way->node_chain;
      while(node_chain) {
        canvas_point_set_pos(points, node++, &node_chain->node->lpos);
        node_chain = node_chain->next;
-Line 269 
 void map_way_select(appdata_t *appdata,
+Line 266 
 void map_way_select(appdata_t *appdata,
      new_map_item->highlight = TRUE;
      map_hl_polyline_new(map, CANVAS_GROUP_WAYS_HL, new_map_item, points,
-                 (map_item->way->draw.flags & OSM_DRAW_FLAG_BG)?
+                  ((map_item->object.way->draw.flags & OSM_DRAW_FLAG_BG)?
-*map->style->highlight.width + map_item->way->draw.bg.width:
+*map->style->highlight.width + map_item->object.way->draw.bg.width:
-*map->style->highlight.width + map_item->way->draw.width,
+*map->style->highlight.width + map_item->object.way->draw.width)
-                 map->style->highlight.color);
+                 * map->state->detail, map->style->highlight.color);
      canvas_points_free(points);
    }
  }
- static void map_item_select(appdata_t *appdata, map_item_t *map_item) {
+ void map_relation_select(appdata_t *appdata, relation_t *relation) {
-   switch(map_item->type) {
+   map_t *map = appdata->map;
-   case MAP_TYPE_NODE:
-     map_node_select(appdata, map_item->node);
+   printf("highlighting relation "ITEM_ID_FORMAT"\n", relation->id);
+   g_assert(!map->highlight);
+   map_highlight_t **hl = &map->highlight;
+   map_item_t *map_item = &map->selected;
+   map_item->object.type      = RELATION;
+   map_item->object.relation  = relation;
+   map_item->highlight = FALSE;
+   map_item->item      = NULL;
+   map_statusbar(map, map_item);
+   icon_bar_map_item_selected(appdata, map_item, TRUE);
+   /* process all members */
+   member_t *member = relation->member;
+   while(member) {
+     canvas_item_t *item = NULL;
+     switch(member->object.type) {
+     case NODE: {
+       node_t *node = member->object.node;
+       printf("  -> node "ITEM_ID_FORMAT"\n", node->id);
+       item = canvas_circle_new(map->canvas, CANVAS_GROUP_NODES_HL,
+                         node->lpos.x, node->lpos.y,
+                         map->style->highlight.width + map->style->node.radius,
+, map->style->highlight.color, NO_COLOR);
+       } break;
+     case WAY: {
+       way_t *way = member->object.way;
+       /* a way needs at least 2 points to be drawn */
+       guint nodes = osm_way_number_of_nodes(way);
+       if(nodes > 1) {
+         /* allocate space for nodes */
+         canvas_points_t *points = canvas_points_new(nodes);
+         int node = 0;
+         node_chain_t *node_chain = way->node_chain;
+         while(node_chain) {
+           canvas_point_set_pos(points, node++, &node_chain->node->lpos);
+           node_chain = node_chain->next;
+         }
+         if(way->draw.flags & OSM_DRAW_FLAG_AREA)
+           item = canvas_polygon_new(map->canvas, CANVAS_GROUP_WAYS_HL, points, 0, 0,
+                                     map->style->highlight.color);
+         else
+           item = canvas_polyline_new(map->canvas, CANVAS_GROUP_WAYS_HL, points,
+                               (way->draw.flags & OSM_DRAW_FLAG_BG)?
+*map->style->highlight.width + way->draw.bg.width:
+*map->style->highlight.width + way->draw.width,
+                               map->style->highlight.color);
+         canvas_points_free(points);
+       } } break;
+     default:
+       break;
+     }
+     /* attach item to item chain */
+     if(item) {
+       *hl = g_new0(map_highlight_t, 1);
+       (*hl)->item = item;
+       hl = &(*hl)->next;
+     }
+     member = member->next;
+   }
+ }
+ static void map_object_select(appdata_t *appdata, object_t *object) {
+   switch(object->type) {
+   case NODE:
+     map_node_select(appdata, object->node);
+     break;
+   case WAY:
+     map_way_select(appdata, object->way);
      break;
-   case MAP_TYPE_WAY:
+   case RELATION:
-     map_way_select(appdata, map_item->way);
+     map_relation_select(appdata, object->relation);
      break;
    default:
-     g_assert((map_item->type == MAP_TYPE_NODE)||
+     g_assert((object->type == NODE)||(object->type == RELATION)||
-              (map_item->type == MAP_TYPE_WAY));
+              (object->type == WAY));
      break;
    }
  }
-Line 296 
 static void map_item_select(appdata_t *a
+Line 374 
 static void map_item_select(appdata_t *a
  void map_item_deselect(appdata_t *appdata) {
    /* save tags for "last" function in info dialog */
-   if(appdata->map->selected.type == MAP_TYPE_NODE) {
+   if(appdata->map->selected.object.type == NODE) {
      if(appdata->map->last_node_tags)
        osm_tags_free(appdata->map->last_node_tags);
      appdata->map->last_node_tags =
-       osm_tags_copy(appdata->map->selected.node->tag, FALSE);
+       osm_tags_copy(appdata->map->selected.object.node->tag);
-   } else if(appdata->map->selected.type == MAP_TYPE_WAY) {
+   } else if(appdata->map->selected.object.type == WAY) {
      if(appdata->map->last_way_tags)
        osm_tags_free(appdata->map->last_way_tags);
      appdata->map->last_way_tags =
-       osm_tags_copy(appdata->map->selected.way->tag, FALSE);
+       osm_tags_copy(appdata->map->selected.object.way->tag);
    }
    /* remove statusbar message */
-Line 321 
 void map_item_deselect(appdata_t *appdat
+Line 399 
 void map_item_deselect(appdata_t *appdat
    map_hl_remove(appdata);
    /* forget about selection */
-   appdata->map->selected.type = MAP_TYPE_ILLEGAL;
+   appdata->map->selected.object.type = ILLEGAL;
  }
  /* called whenever a map item is to be destroyed */
-Line 333 
 static gint map_item_destroy_event(GtkWi
+Line 411 
 static gint map_item_destroy_event(GtkWi
  #ifdef DESTROY_WAIT_FOR_GTK
    /* remove item from nodes/ways map_item_chain */
    map_item_chain_t **chain = NULL;
-   if(map_item->type == MAP_TYPE_NODE)
+   if(map_item->object.type == NODE)
-     chain = &map_item->node->map_item_chain;
+     chain = &map_item->object.node->map_item_chain;
-   else if(map_item->type == MAP_TYPE_WAY)
+   else if(map_item->object.type == WAY)
-     chain = &map_item->way->map_item_chain;
+     chain = &map_item->object.way->map_item_chain;
    /* there must be a chain with content, otherwise things are broken */
    g_assert(chain);
-Line 363 
 static canvas_item_t *map_node_new(map_t
+Line 441 
 static canvas_item_t *map_node_new(map_t
                     gint width, canvas_color_t fill, canvas_color_t border) {
    map_item_t *map_item = g_new0(map_item_t, 1);
-   map_item->type = MAP_TYPE_NODE;
+   map_item->object.type = NODE;
-   map_item->node = node;
+   map_item->object.node = node;
-   if(!node->icon_buf || !map->style->icon.enable)
+   if(!node->icon_buf || !map->style->icon.enable ||
-     map_item->item = canvas_circle_new(map, CANVAS_GROUP_NODES,
+      map->appdata->settings->no_icons)
+     map_item->item = canvas_circle_new(map->canvas, CANVAS_GROUP_NODES,
         node->lpos.x, node->lpos.y, radius, width, fill, border);
    else
-     map_item->item = canvas_image_new(map, CANVAS_GROUP_NODES,
+     map_item->item = canvas_image_new(map->canvas, CANVAS_GROUP_NODES,
        node->icon_buf,
-       node->lpos.x - map->style->icon.scale/2 *
+       node->lpos.x - map->style->icon.scale/2 * map->state->detail *
                        gdk_pixbuf_get_width(node->icon_buf),
-       node->lpos.y - map->style->icon.scale/2 *
+       node->lpos.y - map->style->icon.scale/2 * map->state->detail *
                        gdk_pixbuf_get_height(node->icon_buf),
-               map->style->icon.scale,map->style->icon.scale);
+                       map->state->detail * map->style->icon.scale,
+                       map->state->detail * map->style->icon.scale);
-   canvas_item_set_zoom_max(map_item->item, node->zoom_max);
+   canvas_item_set_zoom_max(map_item->item,
+                            node->zoom_max / (2 * map->state->detail));
    /* attach map_item to nodes map_item_chain */
    map_item_chain_t **chain = &node->map_item_chain;
-Line 400 
 static canvas_item_t *map_way_single_new
+Line 481 
 static canvas_item_t *map_way_single_new
                     gint width, canvas_color_t fill, canvas_color_t border) {
    map_item_t *map_item = g_new0(map_item_t, 1);
-   map_item->type = MAP_TYPE_WAY;
+   map_item->object.type = WAY;
-   map_item->way = way;
+   map_item->object.way = way;
-   map_item->item = canvas_circle_new(map, CANVAS_GROUP_WAYS,
+   map_item->item = canvas_circle_new(map->canvas, CANVAS_GROUP_WAYS,
            way->node_chain->node->lpos.x, way->node_chain->node->lpos.y,
                                       radius, width, fill, border);
-Line 426 
 static canvas_item_t *map_way_new(map_t
+Line 507 
 static canvas_item_t *map_way_new(map_t
            way_t *way, canvas_points_t *points, gint width,
            canvas_color_t color, canvas_color_t fill_color) {
    map_item_t *map_item = g_new0(map_item_t, 1);
-   map_item->type = MAP_TYPE_WAY;
+   map_item->object.type = WAY;
-   map_item->way = way;
+   map_item->object.way = way;
    if(way->draw.flags & OSM_DRAW_FLAG_AREA) {
-     if(map->style->area.opaque)
+     if(map->style->area.color & 0xff)
-       map_item->item = canvas_polygon_new(map, group, points,
+       map_item->item = canvas_polygon_new(map->canvas, group, points,
                                            width, color, fill_color);
      else
-       map_item->item = canvas_polyline_new(map, group, points,
+       map_item->item = canvas_polyline_new(map->canvas, group, points,
                                             width, color);
    } else {
-     map_item->item = canvas_polyline_new(map, group, points, width, color);
+     map_item->item = canvas_polyline_new(map->canvas, group, points, width, color);
    }
-   canvas_item_set_zoom_max(map_item->item, way->draw.zoom_max);
+   canvas_item_set_zoom_max(map_item->item,
+                            way->draw.zoom_max / (2 * map->state->detail));
+   /* a ways outline itself is never dashed */
    if (group != CANVAS_GROUP_WAYS_OL)
      if (way->draw.dashed)
-       canvas_item_set_dashed(map_item->item);
+       canvas_item_set_dashed(map_item->item, width, way->draw.dash_length);
    /* attach map_item to ways map_item_chain */
    map_item_chain_t **chain = &way->map_item_chain;
-Line 462 
 static canvas_item_t *map_way_new(map_t
+Line 545 
 static canvas_item_t *map_way_new(map_t
  void map_show_node(map_t *map, node_t *node) {
    map_node_new(map, node, map->style->node.radius, 0,
-                RGB2CANVAS(map->style->node.color), 0);
+                map->style->node.color, 0);
  }
  void map_way_draw(map_t *map, way_t *way) {
-Line 477 
 void map_way_draw(map_t *map, way_t *way
+Line 560 
 void map_way_draw(map_t *map, way_t *way
    if(nodes == 1) {
      /* draw a single dot where this single node is */
      map_way_single_new(map, way, map->style->node.radius, 0,
-                        RGB2CANVAS(map->style->node.color), 0);
+                        map->style->node.color, 0);
    } else {
      canvas_points_t *points = canvas_points_new(nodes);
-Line 489 
 void map_way_draw(map_t *map, way_t *way
+Line 572 
 void map_way_draw(map_t *map, way_t *way
      }
      /* draw way */
+     float width = way->draw.width * map->state->detail;
      if(way->draw.flags & OSM_DRAW_FLAG_AREA) {
        map_way_new(map, CANVAS_GROUP_POLYGONS, way, points,
-                   way->draw.width, way->draw.color, way->draw.area.color);
+                   width, way->draw.color, way->draw.area.color);
      } else {
-       map_way_new(map, CANVAS_GROUP_WAYS, way, points,
-                   way->draw.width, way->draw.color, NO_COLOR);
+       if(way->draw.flags & OSM_DRAW_FLAG_BG) {
+         map_way_new(map, CANVAS_GROUP_WAYS_INT, way, points,
-       if(way->draw.flags & OSM_DRAW_FLAG_BG)
+                     width, way->draw.color, NO_COLOR);
          map_way_new(map, CANVAS_GROUP_WAYS_OL, way, points,
-                     way->draw.bg.width, way->draw.bg.color, NO_COLOR);
+                     way->draw.bg.width * map->state->detail,
+                     way->draw.bg.color, NO_COLOR);
+       } else
+         map_way_new(map, CANVAS_GROUP_WAYS, way, points,
+                     width, way->draw.color, NO_COLOR);
      }
      canvas_points_free(points);
    }
-Line 511 
 void map_node_draw(map_t *map, node_t *n
+Line 602 
 void map_node_draw(map_t *map, node_t *n
    if(!node->ways)
      map_node_new(map, node,
-                  map->style->node.radius,
+                  map->style->node.radius * map->state->detail,
-                  map->style->node.border_radius,
+                  map->style->node.border_radius * map->state->detail,
-                  RGBA2CANVAS(map->style->node.fill_color,
+                  map->style->node.fill_color,
-                              map->style->node.has_fill_color?0xff:0x00),
+                  map->style->node.color);
-                  RGB2CANVAS(map->style->node.color));
    else if(map->style->node.show_untagged || osm_node_has_tag(node))
      map_node_new(map, node,
-                  map->style->node.radius, 0,
+                  map->style->node.radius * map->state->detail, 0,
-                  RGB2CANVAS(map->style->node.color), 0);
+                  map->style->node.color, 0);
  }
  static void map_item_draw(map_t *map, map_item_t *map_item) {
-   switch(map_item->type) {
+   switch(map_item->object.type) {
-   case MAP_TYPE_NODE:
+   case NODE:
-     map_node_draw(map, map_item->node);
+     map_node_draw(map, map_item->object.node);
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
-     map_way_draw(map, map_item->way);
+     map_way_draw(map, map_item->object.way);
      break;
    default:
-     g_assert((map_item->type == MAP_TYPE_NODE) ||
+     g_assert((map_item->object.type == NODE) ||
-              (map_item->type == MAP_TYPE_WAY));
+              (map_item->object.type == WAY));
    }
  }
  static void map_item_remove(map_t *map, map_item_t *map_item) {
    map_item_chain_t **chainP = NULL;
-   switch(map_item->type) {
+   switch(map_item->object.type) {
-   case MAP_TYPE_NODE:
+   case NODE:
-     chainP = &map_item->node->map_item_chain;
+     chainP = &map_item->object.node->map_item_chain;
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
-     chainP = &map_item->way->map_item_chain;
+     chainP = &map_item->object.way->map_item_chain;
      break;
    default:
-     g_assert((map_item->type == MAP_TYPE_NODE) ||
+     g_assert((map_item->object.type == NODE) ||
-              (map_item->type == MAP_TYPE_WAY));
+              (map_item->object.type == WAY));
    }
    map_item_chain_destroy(chainP);
  }
  static void map_item_init(style_t *style, map_item_t *map_item) {
-   switch (map_item->type){
+   switch (map_item->object.type){
-     case MAP_TYPE_WAY:
+     case WAY:
-       josm_elemstyles_colorize_way(style, map_item->way);
+       josm_elemstyles_colorize_way(style, map_item->object.way);
        break;
-     case MAP_TYPE_NODE:
+     case NODE:
-       josm_elemstyles_colorize_node(style, map_item->node);
+       josm_elemstyles_colorize_node(style, map_item->object.node);
        break;
      default:
-       g_assert((map_item->type == MAP_TYPE_NODE) ||
+       g_assert((map_item->object.type == NODE) ||
-                    (map_item->type == MAP_TYPE_WAY));
+                    (map_item->object.type == WAY));
    }
  }
  void map_item_redraw(appdata_t *appdata, map_item_t *map_item) {
    map_item_t item = *map_item;
+   /* a relation cannot be redraws as it doesn't have a visual */
+   /* representation */
+   if(map_item->object.type == RELATION)
+     return;
    /* check if the item to be redrawn is the selected one */
    gboolean is_selected = FALSE;
-   if(map_item->ptr == appdata->map->selected.ptr) {
+   if(map_item->object.ptr == appdata->map->selected.object.ptr) {
      map_item_deselect(appdata);
      is_selected = TRUE;
    }
-Line 585 
 void map_item_redraw(appdata_t *appdata,
+Line 680 
 void map_item_redraw(appdata_t *appdata,
    /* restore selection if there was one */
    if(is_selected)
-     map_item_select(appdata, &item);
+     map_object_select(appdata, &item.object);
  }
  static void map_frisket_rectangle(canvas_points_t *points,
-Line 602 
 void map_frisket_draw(map_t *map, bounds
+Line 697 
 void map_frisket_draw(map_t *map, bounds
    canvas_points_t *points = canvas_points_new(5);
    /* don't draw frisket at all if it's completely transparent */
-   if(map->style->frisket.opaque) {
+   if(map->style->frisket.color & 0xff) {
-     elemstyle_color_t color =
+     elemstyle_color_t color = map->style->frisket.color;
-       (map->style->background.color<<8) | map->style->frisket.opaque;
      float mult = map->style->frisket.mult;
      /* top rectangle */
      map_frisket_rectangle(points, mult*bounds->min.x, mult*bounds->max.x,
                            mult*bounds->min.y, bounds->min.y);
-     canvas_polygon_new(map, CANVAS_GROUP_NODES, points, 1, NO_COLOR, color);
+     canvas_polygon_new(map->canvas, CANVAS_GROUP_FRISKET, points,
+, NO_COLOR, color);
      /* bottom rectangle */
      map_frisket_rectangle(points, mult*bounds->min.x, mult*bounds->max.x,
                            bounds->max.y, mult*bounds->max.y);
-     canvas_polygon_new(map, CANVAS_GROUP_NODES, points, 1, NO_COLOR, color);
+     canvas_polygon_new(map->canvas, CANVAS_GROUP_FRISKET, points,
+, NO_COLOR, color);
      /* left rectangle */
      map_frisket_rectangle(points, mult*bounds->min.x, bounds->min.x,
                            mult*bounds->min.y, mult*bounds->max.y);
-     canvas_polygon_new(map, CANVAS_GROUP_NODES, points, 1, NO_COLOR, color);
+     canvas_polygon_new(map->canvas, CANVAS_GROUP_FRISKET, points,
+, NO_COLOR, color);
      /* right rectangle */
      map_frisket_rectangle(points, bounds->max.x, mult*bounds->max.x,
                            mult*bounds->min.y, mult*bounds->max.y);
-     canvas_polygon_new(map, CANVAS_GROUP_NODES, points, 1, NO_COLOR, color);
+     canvas_polygon_new(map->canvas, CANVAS_GROUP_FRISKET, points,
+, NO_COLOR, color);
    }
-Line 637 
 void map_frisket_draw(map_t *map, bounds
+Line 735 
 void map_frisket_draw(map_t *map, bounds
                            bounds->min.x-ew2, bounds->max.x+ew2,
                            bounds->min.y-ew2, bounds->max.y+ew2);
-     canvas_polyline_new(map, CANVAS_GROUP_NODES, points,
+     canvas_polyline_new(map->canvas, CANVAS_GROUP_FRISKET, points,
                          map->style->frisket.border.width,
                          map->style->frisket.border.color);
-Line 769 
 map_item_t *map_item_at(map_t *map, gint
+Line 867 
 map_item_t *map_item_at(map_t *map, gint
      return NULL;
    }
    if(map_item->highlight)
      printf("  item is highlight\n");
-   switch(map_item->type) {
+   switch(map_item->object.type) {
-   case MAP_TYPE_NODE:
+   case NODE:
-     printf("  item is node #%ld\n", map_item->node->id);
+     printf("  item is node #"ITEM_ID_FORMAT"\n", map_item->object.node->id);
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
-     printf("  item is way #%ld\n", map_item->way->id);
+     printf("  item is way #"ITEM_ID_FORMAT"\n", map_item->object.way->id);
      break;
    default:
      printf("  unknown item\n");
-Line 788 
 map_item_t *map_item_at(map_t *map, gint
+Line 886 
 map_item_t *map_item_at(map_t *map, gint
  }
  /* get the real item (no highlight) at x, y */
- static map_item_t *map_real_item_at(map_t *map, gint x, gint y) {
+ map_item_t *map_real_item_at(map_t *map, gint x, gint y) {
    map_item_t *map_item = map_item_at(map, x, y);
    /* no item or already a real one */
-Line 796 
 static map_item_t *map_real_item_at(map_
+Line 894 
 static map_item_t *map_real_item_at(map_
    /* get the item (parent) this item is the highlight of */
    map_item_t *parent = NULL;
-   switch(map_item->type) {
+   switch(map_item->object.type) {
-   case MAP_TYPE_NODE:
+   case NODE:
-     if(map_item->node->map_item_chain)
+     if(map_item->object.node->map_item_chain)
-       parent = map_item->node->map_item_chain->map_item;
+       parent = map_item->object.node->map_item_chain->map_item;
      if(parent)
-       printf("  using parent item node #%ld\n", parent->node->id);
+       printf("  using parent item node #" ITEM_ID_FORMAT "\n",
+              parent->object.node->id);
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
-     if(map_item->way->map_item_chain)
+     if(map_item->object.way->map_item_chain)
-       parent = map_item->way->map_item_chain->map_item;
+       parent = map_item->object.way->map_item_chain->map_item;
      if(parent)
-       printf("  using parent item way #%ld\n", parent->way->id);
+       printf("  using parent item way #" ITEM_ID_FORMAT "\n",
+              parent->object.way->id);
      break;
    default:
-     g_assert((map_item->type == MAP_TYPE_NODE) ||
+     g_assert((map_item->object.type == NODE) ||
-              (map_item->type == MAP_TYPE_WAY));
+              (map_item->object.type == WAY));
      break;
    }
-Line 828 
 static map_item_t *map_real_item_at(map_
+Line 928 
 static map_item_t *map_real_item_at(map_
    return map_item;
  }
- #ifdef USE_GOOCANVAS
  /* Limitations on the amount by which we can scroll. Keeps part of the
   * map visible at all times */
- static void map_limit_scroll(map_t *map, gint *sx, gint *sy) {
+ static void map_limit_scroll(map_t *map, canvas_unit_t unit,
-     gdouble zoom = goo_canvas_get_scale(GOO_CANVAS(map->canvas));
+                              gint *sx, gint *sy) {
-     gint sx_cu = *sx / zoom;
+   /* get scale factor for pixel->meter conversion. set to 1 if */
-     gint sy_cu = *sy / zoom;
+   /* given coordinates are already in meters */
+   gdouble scale = (unit == CANVAS_UNIT_METER)?1.0:canvas_get_zoom(map->canvas);
-     // Canvas viewport dimensions
-     GtkAllocation *a = &GTK_WIDGET(map->canvas)->allocation;
+   /* convert pixels to meters if necessary */
-     gint aw_cu = a->width / zoom;
+   gdouble sx_cu = *sx / scale;
-     gint ah_cu = a->height / zoom;
+   gdouble sy_cu = *sy / scale;
-     // Data rect minimum and maximum
+   /* get size of visible area in canvas units (meters) */
-     gint min_x, min_y, max_x, max_y;
+   gint aw_cu = canvas_get_viewport_width(map->canvas, CANVAS_UNIT_METER);
-     min_x = map->appdata->osm->bounds->min.x;
+   gint ah_cu = canvas_get_viewport_height(map->canvas, CANVAS_UNIT_METER);
-     min_y = map->appdata->osm->bounds->min.y;
-     max_x = map->appdata->osm->bounds->max.x;
+   // Data rect minimum and maximum
-     max_y = map->appdata->osm->bounds->max.y;
+   gint min_x, min_y, max_x, max_y;
+   min_x = map->appdata->osm->bounds->min.x;
-     // limit stops - prevent scrolling beyond these
+   min_y = map->appdata->osm->bounds->min.y;
-     gint min_sy_cu = 0.95*(min_y - ah_cu);
+   max_x = map->appdata->osm->bounds->max.x;
-     gint min_sx_cu = 0.95*(min_x - aw_cu);
+   max_y = map->appdata->osm->bounds->max.y;
-     gint max_sy_cu = 0.95*(max_y);
-     gint max_sx_cu = 0.95*(max_x);
+   // limit stops - prevent scrolling beyond these
-     if (sy_cu < min_sy_cu) { *sy = min_sy_cu*zoom; }
+   gint min_sy_cu = 0.95*(min_y - ah_cu);
-     if (sx_cu < min_sx_cu) { *sx = min_sx_cu*zoom; }
+   gint min_sx_cu = 0.95*(min_x - aw_cu);
-     if (sy_cu > max_sy_cu) { *sy = max_sy_cu*zoom; }
+   gint max_sy_cu = 0.95*(max_y);
-     if (sx_cu > max_sx_cu) { *sx = max_sx_cu*zoom; }
+   gint max_sx_cu = 0.95*(max_x);
+   if (sy_cu < min_sy_cu) { *sy = min_sy_cu * scale; }
+   if (sx_cu < min_sx_cu) { *sx = min_sx_cu * scale; }
+   if (sy_cu > max_sy_cu) { *sy = max_sy_cu * scale; }
+   if (sx_cu > max_sx_cu) { *sx = max_sx_cu * scale; }
  }
-Line 874 
 static gboolean map_limit_zoom(map_t *ma
+Line 974 
 static gboolean map_limit_zoom(map_t *ma
      max_x = map->appdata->osm->bounds->max.x;
      max_y = map->appdata->osm->bounds->max.y;
-     // Canvas viewport dimensions
+     /* get size of visible area in pixels and convert to meters of intended */
-     GtkAllocation *a = &GTK_WIDGET(map->canvas)->allocation;
+     /* zoom by deviding by zoom (which is basically pix/m) */
-     gint ah_cu = a->height / *zoom;
+     gint aw_cu =
-     gint aw_cu = a->width / *zoom;
+       canvas_get_viewport_width(map->canvas, CANVAS_UNIT_PIXEL) / *zoom;
+     gint ah_cu =
+       canvas_get_viewport_height(map->canvas, CANVAS_UNIT_PIXEL) / *zoom;
      gdouble oldzoom = *zoom;
      if (ah_cu < aw_cu) {
-Line 895 
 static gboolean map_limit_zoom(map_t *ma
+Line 997 
 static gboolean map_limit_zoom(map_t *ma
          }
      }
      if (*zoom != oldzoom) {
-         printf("Can't zoom further out\n");
+         printf("Can't zoom further out (%f)\n", *zoom);
          return 1;
      }
      return 0;
  }
- #if 0
- /* Scroll the map a little towards the centre from where it is right now.
-  * This is used as a cute recentring trick when the map is at its outer
-  * scroll limit. */
- static void map_scroll_towards_centre(map_t *map, gdouble amt) {
-     gint sx, sy, sx_orig, sy_orig;
-     canvas_get_scroll_offsets(map->canvas, &sx, &sy);
-     gdouble zoom = goo_canvas_get_scale(GOO_CANVAS(map->canvas));
-     sx_orig=sx;
-     sy_orig=sy;
-     // Work in canvas units
-     gdouble sx_cu = sx / zoom;
-     gdouble sy_cu = sy / zoom;
-     // Map bounds
-     gdouble bmin_x_cu, bmin_y_cu, bmax_x_cu, bmax_y_cu;
-     bmin_x_cu = map->appdata->osm->bounds->min.x;
-     bmin_y_cu = map->appdata->osm->bounds->min.y;
-     bmax_x_cu = map->appdata->osm->bounds->max.x;
-     bmax_y_cu = map->appdata->osm->bounds->max.y;
-     // Canvas viewport dimensions
-     GtkAllocation *a = &GTK_WIDGET(map->canvas)->allocation;
-     gdouble ah_cu = a->height / zoom;
-     gdouble aw_cu = a->width / zoom;
-     // Scroll offsets that would recentre the map
-     gdouble centre_sx_cu, centre_sy_cu;
-     centre_sx_cu = - (aw_cu/2);
-     centre_sy_cu = - (ah_cu/2);
-     // Move towards centre by a given fraction of the whole map
-     if (sx_cu > centre_sx_cu) {
-         sx_cu -= ((bmax_x_cu - bmin_x_cu) * amt);
-         if (sx_cu < centre_sx_cu) {
-             printf("force-centre-x\n");
-             sx_cu = centre_sx_cu;
-         }
-     }
-     if (sx_cu < centre_sx_cu) {
-         sx_cu += ((bmax_x_cu - bmin_x_cu) * amt);
-         if (sx_cu > centre_sx_cu) {
-             printf("force-centre-x\n");
-             sx_cu = centre_sx_cu;
-         }
-     }
-     if (sy_cu > centre_sy_cu) {
-         sy_cu -= ((bmax_y_cu - bmin_y_cu) * amt);
-         if (sy_cu < centre_sy_cu) {
-             printf("force-centre-y\n");
-             sy_cu = centre_sy_cu;
-         }
-     }
-     if (sy_cu < centre_sy_cu) {
-         sy_cu += ((bmax_y_cu - bmin_y_cu) * amt);
-         if (sy_cu > centre_sy_cu) {
-             printf("force-centre-y\n");
-             sy_cu = centre_sy_cu;
-         }
-     }
-     // Back to pixels for setting the scroll
-     sx = (gint)(sx_cu * zoom);
-     sy = (gint)(sy_cu * zoom);
-     canvas_scroll_to(map->canvas, sx, sy);
-     map->state->scroll_offset.x = sx;
-     map->state->scroll_offset.y = sy;
- }
- #endif // #if 0
  /*
   * Scroll the map to a point if that point is currently offscreen.
   */
-Line 990 
 void map_scroll_to_if_offscreen(map_t *m
+Line 1020 
 void map_scroll_to_if_offscreen(map_t *m
    max_y = map->appdata->osm->bounds->max.y;
    if (   (lpos->x > max_x) || (lpos->x < min_x)
        || (lpos->y > max_y) || (lpos->y < min_y)) {
-     printf("cannot scroll to (%d, %d): outside the working area\n");
+     printf("cannot scroll to (%d, %d): outside the working area\n",
+            lpos->x, lpos->y);
      return;
    }
    // Viewport dimensions in canvas space
-   gdouble zoom = goo_canvas_get_scale(GOO_CANVAS(map->canvas));
-   GtkAllocation *a = &GTK_WIDGET(map->canvas)->allocation;
+   /* get size of visible area in canvas units (meters) */
-   gdouble aw = a->width / zoom;
+   gdouble pix_per_meter = canvas_get_zoom(map->canvas);
-   gdouble ah = a->height / zoom;
+   gdouble aw = canvas_get_viewport_width(map->canvas, CANVAS_UNIT_METER);
+   gdouble ah = canvas_get_viewport_height(map->canvas, CANVAS_UNIT_METER);
    // Is the point still onscreen?
    gboolean vert_recentre_needed = FALSE;
    gboolean horiz_recentre_needed = FALSE;
    gint sx, sy;
-   canvas_get_scroll_offsets(map->canvas, &sx, &sy);
+   canvas_scroll_get(map->canvas, CANVAS_UNIT_PIXEL, &sx, &sy);
-   gint viewport_left   = (sx/zoom);
+   gint viewport_left   = (sx/pix_per_meter);
-   gint viewport_right  = (sx/zoom)+aw;
+   gint viewport_right  = (sx/pix_per_meter)+aw;
-   gint viewport_top    = (sy/zoom);
+   gint viewport_top    = (sy/pix_per_meter);
-   gint viewport_bottom = (sy/zoom)+ah;
+   gint viewport_bottom = (sy/pix_per_meter)+ah;
    if (lpos->x > viewport_right) {
      printf("** off right edge (%d > %d)\n", lpos->x, viewport_right);
      horiz_recentre_needed = TRUE;
-Line 1028 
 void map_scroll_to_if_offscreen(map_t *m
+Line 1060 
 void map_scroll_to_if_offscreen(map_t *m
    if (horiz_recentre_needed || vert_recentre_needed) {
      gint new_sx, new_sy;
- #if 0
-     // Only recentre the drifting axis.
-     new_sx = horiz_recentre_needed ? zoom*(lpos->x - (aw/2)) : sx;
-     new_sy = vert_recentre_needed  ? zoom*(lpos->y - (ah/2)) : sy;
-     // Not sure about this. I don't think it really buys us anything.
- #else
      // Just centre both at once
-     new_sx = zoom * (lpos->x - (aw/2));
+     new_sx = pix_per_meter * (lpos->x - (aw/2));
-     new_sy = zoom * (lpos->y - (ah/2));
+     new_sy = pix_per_meter * (lpos->y - (ah/2));
- #endif
-     map_limit_scroll(map, &new_sx, &new_sy);
+     map_limit_scroll(map, CANVAS_UNIT_PIXEL, &new_sx, &new_sy);
-     canvas_scroll_to(map->canvas, new_sx, new_sy);
+     canvas_scroll_to(map->canvas, CANVAS_UNIT_PIXEL, new_sx, new_sy);
    }
  }
- #endif // #ifdef USE_GOOCANVAS
  /* Deselects the current way or node if its zoom_max
   * means that it's not going to render at the current map zoom. */
  void map_deselect_if_zoom_below_zoom_max(map_t *map) {
-     if (map->selected.type == MAP_TYPE_WAY) {
+     if (map->selected.object.type == WAY) {
          printf("will deselect way if zoomed below %f\n",
-                map->selected.way->draw.zoom_max);
+                map->selected.object.way->draw.zoom_max);
-         if (map->state->zoom < map->selected.way->draw.zoom_max) {
+         if (map->state->zoom < map->selected.object.way->draw.zoom_max) {
              printf("  deselecting way!\n");
              map_item_deselect(map->appdata);
          }
      }
-     else if (map->selected.type == MAP_TYPE_NODE) {
+     else if (map->selected.object.type == NODE) {
          printf("will deselect node if zoomed below %f\n",
-                map->selected.node->zoom_max);
+                map->selected.object.node->zoom_max);
-         if (map->state->zoom < map->selected.node->zoom_max) {
+         if (map->state->zoom < map->selected.object.node->zoom_max) {
              printf("  deselecting node!\n");
              map_item_deselect(map->appdata);
          }
-Line 1069 
 void map_deselect_if_zoom_below_zoom_max
+Line 1094 
 void map_deselect_if_zoom_below_zoom_max
  void map_set_zoom(map_t *map, double zoom,
                    gboolean update_scroll_offsets) {
    gboolean at_zoom_limit = 0;
- #ifdef USE_GOOCANVAS
    at_zoom_limit = map_limit_zoom(map, &zoom);
- #endif
    map->state->zoom = zoom;
    canvas_set_zoom(map->canvas, map->state->zoom);
    map_deselect_if_zoom_below_zoom_max(map);
-   if (update_scroll_offsets) {
+   if(update_scroll_offsets) {
      if (!at_zoom_limit) {
        /* zooming affects the scroll offsets */
        gint sx, sy;
-       canvas_get_scroll_offsets(map->canvas, &sx, &sy);
+       canvas_scroll_get(map->canvas, CANVAS_UNIT_PIXEL, &sx, &sy);
- #ifdef USE_GOOCANVAS
+       map_limit_scroll(map, CANVAS_UNIT_PIXEL, &sx, &sy);
-       map_limit_scroll(map, &sx, &sy);
-       canvas_scroll_to(map->canvas, sx, sy);  // keep the map visible
+       // keep the map visible
- #endif
+       canvas_scroll_to(map->canvas, CANVAS_UNIT_PIXEL, sx, sy);
-       map->state->scroll_offset.x = sx;
-       map->state->scroll_offset.y = sy;
-     }
- #ifdef USE_GOOCANVAS
-     else {
-       //      map_scroll_towards_centre(map, 0.20);
      }
- #endif
+     canvas_scroll_get(map->canvas, CANVAS_UNIT_METER,
+                       &map->state->scroll_offset.x,
+                       &map->state->scroll_offset.y);
    }
  }
-Line 1118 
 static gboolean map_scroll_event(GtkWidg
+Line 1139 
 static gboolean map_scroll_event(GtkWidg
  static gboolean distance_above(map_t *map, gint x, gint y, gint limit) {
    gint sx, sy;
- #ifdef USE_GNOMECANVAS
-   gnome_canvas_get_scroll_offsets(GNOME_CANVAS(map->canvas), &sx, &sy);
-   /* add offsets generated by mouse within map and map scrolling */
-   sx = (x-map->pen_down.at.x) + (map->pen_down.so.x-sx);
-   sy = (y-map->pen_down.at.y) + (map->pen_down.so.y-sy);
- #else
    /* add offsets generated by mouse within map and map scrolling */
    sx = (x-map->pen_down.at.x);
    sy = (y-map->pen_down.at.y);
- #endif
    return(sx*sx + sy*sy > limit*limit);
  }
-Line 1137 
 static gboolean distance_above(map_t *ma
+Line 1150 
 static gboolean distance_above(map_t *ma
  static void map_do_scroll(map_t *map, gint x, gint y) {
    gint sx, sy;
-   canvas_get_scroll_offsets(map->canvas, &sx, &sy);
+   canvas_scroll_get(map->canvas, CANVAS_UNIT_PIXEL, &sx, &sy);
    sx -= x-map->pen_down.at.x;
    sy -= y-map->pen_down.at.y;
- #ifdef USE_GOOCANVAS
+   map_limit_scroll(map, CANVAS_UNIT_PIXEL, &sx, &sy);
-   map_limit_scroll(map, &sx, &sy);
+   canvas_scroll_to(map->canvas, CANVAS_UNIT_PIXEL, sx, sy);
- #endif
-   canvas_scroll_to(map->canvas, sx, sy);
+   canvas_scroll_get(map->canvas, CANVAS_UNIT_METER,
-   map->state->scroll_offset.x = sx;
+                     &map->state->scroll_offset.x,
-   map->state->scroll_offset.y = sy;
+                     &map->state->scroll_offset.y);
  }
  /* scroll a certain step */
  static void map_do_scroll_step(map_t *map, gint x, gint y) {
    gint sx, sy;
-   canvas_get_scroll_offsets(map->canvas, &sx, &sy);
+   canvas_scroll_get(map->canvas, CANVAS_UNIT_PIXEL, &sx, &sy);
    sx += x;
    sy += y;
- #ifdef USE_GOOCANVAS
+   map_limit_scroll(map, CANVAS_UNIT_PIXEL, &sx, &sy);
-   map_limit_scroll(map, &sx, &sy);
+   canvas_scroll_to(map->canvas, CANVAS_UNIT_PIXEL, sx, sy);
- #endif
-   canvas_scroll_to(map->canvas, sx, sy);
-   map->state->scroll_offset.x = sx;
-   map->state->scroll_offset.y = sy;
- }
+   canvas_scroll_get(map->canvas, CANVAS_UNIT_METER,
+                     &map->state->scroll_offset.x,
+                     &map->state->scroll_offset.y);
+ }
  gboolean map_item_is_selected_node(map_t *map, map_item_t *map_item) {
    printf("check if item is a selected node\n");
-Line 1172 
 gboolean map_item_is_selected_node(map_t
+Line 1184 
 gboolean map_item_is_selected_node(map_t
      return FALSE;
    }
-   if(map->selected.type == MAP_TYPE_ILLEGAL) {
+   if(map->selected.object.type == ILLEGAL) {
      printf("  nothing is selected\n");
      return FALSE;
    }
    /* clicked the highlight directly */
-   if(map_item->type != MAP_TYPE_NODE) {
+   if(map_item->object.type != NODE) {
      printf("  didn't click node\n");
      return FALSE;
    }
-   if(map->selected.type == MAP_TYPE_NODE) {
+   if(map->selected.object.type == NODE) {
      printf("  selected item is a node\n");
-     if(map_item->node == map->selected.node) {
+     if(map_item->object.node == map->selected.object.node) {
        printf("  requested item is a selected node\n");
        return TRUE;
      }
      printf("  but it's not the requested one\n");
      return FALSE;
-   } else if(map->selected.type == MAP_TYPE_WAY) {
+   } else if(map->selected.object.type == WAY) {
      printf("  selected item is a way\n");
-     node_chain_t *node_chain = map->selected.way->node_chain;
+     node_chain_t *node_chain = map->selected.object.way->node_chain;
      while(node_chain) {
-       if(node_chain->node == map_item->node) {
+       if(node_chain->node == map_item->object.node) {
          printf("  requested item is part of selected way\n");
          return TRUE;
        }
-Line 1226 
 gboolean map_item_is_selected_way(map_t
+Line 1238 
 gboolean map_item_is_selected_way(map_t
      return FALSE;
    }
-   if(map->selected.type == MAP_TYPE_ILLEGAL) {
+   if(map->selected.object.type == ILLEGAL) {
      printf("  nothing is selected\n");
      return FALSE;
    }
    /* clicked the highlight directly */
-   if(map_item->type != MAP_TYPE_WAY) {
+   if(map_item->object.type != WAY) {
      printf("  didn't click way\n");
      return FALSE;
    }
-   if(map->selected.type == MAP_TYPE_WAY) {
+   if(map->selected.object.type == WAY) {
      printf("  selected item is a way\n");
-     if(map_item->way == map->selected.way) {
+     if(map_item->object.way == map->selected.object.way) {
        printf("  requested item is a selected way\n");
        return TRUE;
      }
-Line 1255 
 gboolean map_item_is_selected_way(map_t
+Line 1267 
 gboolean map_item_is_selected_way(map_t
  void map_highlight_refresh(appdata_t *appdata) {
    map_t *map = appdata->map;
-   map_item_t old = map->selected;
+   object_t old = map->selected.object;
    printf("type to refresh is %d\n", old.type);
-   if(old.type == MAP_TYPE_ILLEGAL)
+   if(old.type == ILLEGAL)
      return;
    map_item_deselect(appdata);
-   map_item_select(appdata, &old);
+   map_object_select(appdata, &old);
  }
  void map_way_delete(appdata_t *appdata, way_t *way) {
-   printf("deleting way #%ld from map and osm\n", way->id);
+   printf("deleting way #" ITEM_ID_FORMAT " from map and osm\n", way->id);
    /* remove it visually from the screen */
    map_item_chain_destroy(&way->map_item_chain);
-Line 1290 
 static void map_handle_click(appdata_t *
+Line 1302 
 static void map_handle_click(appdata_t *
    /* problem: on_item may be the highlight itself! So store it! */
    map_item_t map_item;
    if(map->pen_down.on_item) map_item = *map->pen_down.on_item;
-   else                      map_item.type = MAP_TYPE_ILLEGAL;
+   else                      map_item.object.type = ILLEGAL;
    /* if we aready have something selected, then de-select it */
    map_item_deselect(appdata);
    /* select the clicked item (if there was one) */
-   if(map_item.type != MAP_TYPE_ILLEGAL) {
+   if(map_item.object.type != ILLEGAL) {
-     switch(map_item.type) {
+     switch(map_item.object.type) {
-     case MAP_TYPE_NODE:
+     case NODE:
-       map_node_select(appdata, map_item.node);
+       map_node_select(appdata, map_item.object.node);
        break;
-     case MAP_TYPE_WAY:
+     case WAY:
-       map_way_select(appdata, map_item.way);
+       map_way_select(appdata, map_item.object.way);
        break;
      default:
-       g_assert((map_item.type == MAP_TYPE_NODE) ||
+       g_assert((map_item.object.type == NODE) ||
-                (map_item.type == MAP_TYPE_WAY));
+                (map_item.object.type == WAY));
        break;
      }
    }
-Line 1328 
 static void map_touchnode_update(appdata
+Line 1340 
 static void map_touchnode_update(appdata
      /* in idle mode the dragged node is not highlighted */
    case MAP_ACTION_IDLE:
      g_assert(map->pen_down.on_item);
-     g_assert(map->pen_down.on_item->type == MAP_TYPE_NODE);
+     g_assert(map->pen_down.on_item->object.type == NODE);
-     cur_node = map->pen_down.on_item->node;
+     cur_node = map->pen_down.on_item->object.node;
      break;
    default:
-Line 1344 
 static void map_touchnode_update(appdata
+Line 1356 
 static void map_touchnode_update(appdata
      /* don't highlight the dragged node itself and don't highlight */
      /* deleted ones */
      if((node != cur_node) && (!(node->flags & OSM_FLAG_DELETED))) {
-       gint nx = x - node->lpos.x;
+       gint nx = abs(x - node->lpos.x);
-       gint ny = y - node->lpos.y;
+       gint ny = abs(y - node->lpos.y);
        if((nx < map->style->node.radius) && (ny < map->style->node.radius) &&
           (nx*nx + ny*ny < map->style->node.radius * map->style->node.radius))
-Line 1359 
 static void map_touchnode_update(appdata
+Line 1371 
 static void map_touchnode_update(appdata
    if(!map->touchnode && map->action.way) {
      node_chain_t *chain = map->action.way->node_chain;
      while(!map->touchnode && chain && chain->next) {
-       gint nx = x - chain->node->lpos.x;
+       gint nx = abs(x - chain->node->lpos.x);
-       gint ny = y - chain->node->lpos.y;
+       gint ny = abs(y - chain->node->lpos.y);
        if((nx < map->style->node.radius) && (ny < map->style->node.radius) &&
           (nx*nx + ny*ny < map->style->node.radius * map->style->node.radius))
-Line 1381 
 static void map_button_press(map_t *map,
+Line 1393 
 static void map_button_press(map_t *map,
    map->pen_down.at.y = y;
    map->pen_down.drag = FALSE;     // don't assume drag yet
- #ifdef USE_GNOMECANVAS
-   /* save initial scroll offset */
-   gnome_canvas_get_scroll_offsets(GNOME_CANVAS(map->canvas),
-                   &map->pen_down.so.x, &map->pen_down.so.y);
- #endif
    /* determine wether this press was on an item */
    map->pen_down.on_item = map_real_item_at(map, x, y);
-Line 1458 
 static void map_button_release(map_t *ma
+Line 1464 
 static void map_button_release(map_t *ma
        map_item_t old_sel = map->selected;
        map_handle_click(map->appdata, map);
-       if((old_sel.type != MAP_TYPE_ILLEGAL) &&
+       if((old_sel.object.type != ILLEGAL) &&
-          (old_sel.type == map->selected.type) &&
+          (old_sel.object.type == map->selected.object.type) &&
-          (old_sel.ptr == map->selected.ptr)) {
+          (old_sel.object.ptr == map->selected.object.ptr)) {
          printf("re-selected same item of type %d, "
-                "pushing it to the bottom\n", old_sel.type);
+                "pushing it to the bottom\n", old_sel.object.type);
          if(!map->selected.item) {
            printf("  item has no visible representation to push\n");
-Line 1579 
 static gboolean map_motion_notify_event(
+Line 1585 
 static gboolean map_motion_notify_event(
    /* reduce update frequency on hildon to keep screen update fluid */
    static guint32 last_time = 0;
-   if(event->time - last_time < 100) return FALSE;
+   if(event->time - last_time < 250) return FALSE;
    last_time = event->time;
  #endif
    if(!map->pen_down.is)
      return FALSE;
- #ifdef USE_GNOMECANVAS
+ #ifndef USE_GOOCANVAS
    /* handle hints, hints are handled by goocanvas directly */
    if(event->is_hint)
      gdk_window_get_pointer(event->window, &x, &y, &state);
-Line 1623 
 static gboolean map_motion_notify_event(
+Line 1629 
 static gboolean map_motion_notify_event(
    case MAP_ACTION_NODE_ADD:
      map_hl_cursor_draw(map, x, y, FALSE, map->style->node.radius);
      break;
    case MAP_ACTION_WAY_ADD:
      map_hl_cursor_draw(map, x, y, FALSE, map->style->node.radius);
      map_touchnode_update(appdata, x, y);
-Line 1724 
 gboolean map_key_press_event(appdata_t *
+Line 1730 
 gboolean map_key_press_event(appdata_t *
    return FALSE;
  }
+ void map_state_reset(map_state_t *state) {
+   if(!state) return;
+   state->zoom = 0.25;
+   state->detail = 1.0;
+   /* todo: try to scroll to center of screen */
+   state->scroll_offset.x = 0;
+   state->scroll_offset.y = 0;
+ }
+ map_state_t *map_state_new(void) {
+   map_state_t *state = g_new0(map_state_t, 1);
+   map_state_reset(state);
+   return state;
+ }
  GtkWidget *map_new(appdata_t *appdata) {
    map_t *map = appdata->map = g_new0(map_t, 1);
    map->style = style_load(appdata, appdata->settings->style);
+   if(!map->style) {
+     errorf(NULL, _("Unable to load valid style, terminating."));
+     g_free(map);
+     return NULL;
+   }
    if(appdata->project && appdata->project->map_state) {
      printf("Using projects map state\n");
      map->state = appdata->project->map_state;
    } else {
      printf("Creating new map state\n");
-     map->state = g_new0(map_state_t, 1);
+     map->state = map_state_new();
-     map->state->zoom = 0.25;
    }
    map->state->refcount++;
-Line 1745 
 GtkWidget *map_new(appdata_t *appdata) {
+Line 1772 
 GtkWidget *map_new(appdata_t *appdata) {
    map->appdata = appdata;
    map->action.type = MAP_ACTION_IDLE;
- #ifdef USE_GNOMECANVAS
+   map->canvas = canvas_new();
-   map->canvas = gnome_canvas_new_aa();  // _aa
-   /* create the groups */
+   GtkWidget *canvas_widget = canvas_get_widget(map->canvas);
-   canvas_group_t group;
-   for(group = 0; group < CANVAS_GROUPS; group++)
-     map->group[group] = gnome_canvas_item_new(
-                 gnome_canvas_root(GNOME_CANVAS(map->canvas)),
-                 GNOME_TYPE_CANVAS_GROUP,
-                 NULL);
-   gtk_widget_modify_bg(map->canvas, GTK_STATE_NORMAL,
+   gtk_widget_set_events(canvas_widget,
-                        &map->canvas->style->white);
- #else
-   map->canvas = goo_canvas_new();
-   g_object_set(G_OBJECT(map->canvas), "anchor", GTK_ANCHOR_CENTER, NULL);
-   g_object_set(G_OBJECT(map->canvas), "background-color-rgb",
-                map->style->background.color, NULL);
-   GooCanvasItem *root = goo_canvas_get_root_item(GOO_CANVAS(map->canvas));
-   /* create the groups */
-   canvas_group_t group;
-   for(group = 0; group < CANVAS_GROUPS; group++)
-     map->group[group] = goo_canvas_group_new(root, NULL);
- #endif
-   gtk_widget_set_events(map->canvas,
                            GDK_BUTTON_PRESS_MASK
                          | GDK_BUTTON_RELEASE_MASK
                          | GDK_SCROLL_MASK
                          | GDK_POINTER_MOTION_MASK
                          | GDK_POINTER_MOTION_HINT_MASK);
-   gtk_signal_connect(GTK_OBJECT(map->canvas),
+   gtk_signal_connect(GTK_OBJECT(canvas_widget),
       "button_press_event", G_CALLBACK(map_button_event), appdata);
-   gtk_signal_connect(GTK_OBJECT(map->canvas),
+   gtk_signal_connect(GTK_OBJECT(canvas_widget),
       "button_release_event", G_CALLBACK(map_button_event), appdata);
-   gtk_signal_connect(GTK_OBJECT(map->canvas),
+   gtk_signal_connect(GTK_OBJECT(canvas_widget),
       "motion_notify_event", G_CALLBACK(map_motion_notify_event), appdata);
-   gtk_signal_connect(GTK_OBJECT(map->canvas),
+   gtk_signal_connect(GTK_OBJECT(canvas_widget),
       "scroll_event", G_CALLBACK(map_scroll_event), appdata);
-   gtk_signal_connect(GTK_OBJECT(map->canvas),
+   gtk_signal_connect(GTK_OBJECT(canvas_widget),
       "destroy", G_CALLBACK(map_destroy_event), appdata);
-   return map->canvas;
+   return canvas_widget;
  }
  void map_init(appdata_t *appdata) {
    map_t *map = appdata->map;
+   /* update canvas background color */
+   canvas_set_background(map->canvas, map->style->background.color);
    /* set initial zoom */
    map_set_zoom(map, map->state->zoom, FALSE);
    josm_elemstyles_colorize_world(map->style, appdata->osm);
-Line 1813 
 void map_init(appdata_t *appdata) {
+Line 1817 
 void map_init(appdata_t *appdata) {
                      mult*appdata->osm->bounds->max.x,
                      mult*appdata->osm->bounds->max.y);
-   printf("restore scroll offsets %d/%d\n",
+   printf("restore scroll position %d/%d\n",
           map->state->scroll_offset.x, map->state->scroll_offset.y);
-   canvas_scroll_to(map->canvas,
+   map_limit_scroll(map, CANVAS_UNIT_METER,
-                    map->state->scroll_offset.x, map->state->scroll_offset.y);
+            &map->state->scroll_offset.x, &map->state->scroll_offset.y);
+   canvas_scroll_to(map->canvas, CANVAS_UNIT_METER,
+            map->state->scroll_offset.x, map->state->scroll_offset.y);
  }
- void map_item_set_flags(map_item_t *map_item, int set, int clr) {
+ void map_clear(appdata_t *appdata, gint group_mask) {
-   switch(map_item->type) {
-   case MAP_TYPE_NODE:
-     map_item->node->flags |=  set;
-     map_item->node->flags &= ~clr;
-     break;
-   case MAP_TYPE_WAY:
-     map_item->way->flags |=  set;
-     map_item->way->flags &= ~clr;
-     break;
-   default:
-     g_assert(0);
-     break;
-   }
- }
- void map_clear(appdata_t *appdata, gint layer_mask) {
    map_t *map = appdata->map;
    printf("freeing map contents\n");
-Line 1850 
 void map_clear(appdata_t *appdata, gint
+Line 1837 
 void map_clear(appdata_t *appdata, gint
    /* remove a possibly existing highlight */
    map_item_deselect(appdata);
-   canvas_group_t group;
+   canvas_erase(map->canvas, group_mask);
-   for(group=0;group<CANVAS_GROUPS;group++) {
- #ifdef USE_GNOMECANVAS
-     /* destroy the entire group */
-     canvas_item_destroy(map->group[group]);
-     /* and create an empty new one */
-     map->group[group] = gnome_canvas_item_new(
-                       gnome_canvas_root(GNOME_CANVAS(map->canvas)),
-                       GNOME_TYPE_CANVAS_GROUP,
-                       NULL);
- #else
-     if(layer_mask & (1<<group)) {
-       gint children = goo_canvas_item_get_n_children(map->group[group]);
-       printf("Removing %d children from layer %d\n", children, group);
-       while(children--)
-         goo_canvas_item_remove_child(map->group[group], children);
-     }
- #endif
-   }
  }
  void map_paint(appdata_t *appdata) {
-Line 1907 
 void map_action_set(appdata_t *appdata,
+Line 1874 
 void map_action_set(appdata_t *appdata,
      /* remember if there was a way selected */
      way_t *way_sel = NULL;
-     if(appdata->map->selected.type == MAP_TYPE_WAY)
+     if(appdata->map->selected.object.type == WAY)
-       way_sel = appdata->map->selected.way;
+       way_sel = appdata->map->selected.object.way;
      map_item_deselect(appdata);
      map_edit_way_add_begin(appdata->map, way_sel);
-Line 1983 
 void map_action_ok(appdata_t *appdata) {
+Line 1950 
 void map_action_ok(appdata_t *appdata) {
      /* save changes to bg_offset in project */
      appdata->project->wms_offset.x = map->bg.offset.x;
      appdata->project->wms_offset.y = map->bg.offset.y;
-     appdata->project->dirty = TRUE;
      break;
    default:
-Line 2007 
 void map_delete_selected(appdata_t *appd
+Line 1973 
 void map_delete_selected(appdata_t *appd
    /* deleting the selected item de-selects it ... */
    map_item_deselect(appdata);
-   switch(item.type) {
+   undo_remember_delete(appdata, &item.object);
-   case MAP_TYPE_NODE:
-     printf("request to delete node #%ld\n", item.node->id);
+   switch(item.object.type) {
+   case NODE:
+     printf("request to delete node #" ITEM_ID_FORMAT "\n",
+            item.object.node->id);
      /* check if this node is part of a way with two nodes only. */
      /* we cannot delete this as this would also delete the way */
-     way_chain_t *way_chain = osm_node_to_way(appdata->osm, item.node);
+     way_chain_t *way_chain = osm_node_to_way(appdata->osm, item.object.node);
      if(way_chain) {
        gboolean short_way = FALSE;
-Line 2039 
 void map_delete_selected(appdata_t *appd
+Line 2008 
 void map_delete_selected(appdata_t *appd
      }
      /* remove it visually from the screen */
-     map_item_chain_destroy(&item.node->map_item_chain);
+     map_item_chain_destroy(&item.object.node->map_item_chain);
      /* and mark it "deleted" in the database */
-     osm_node_remove_from_relation(appdata->osm, item.node);
+     osm_node_remove_from_relation(appdata->osm, item.object.node);
      way_chain_t *chain = osm_node_delete(appdata->osm,
-                          &appdata->icon, item.node, FALSE, TRUE);
+                          &appdata->icon, item.object.node, FALSE, TRUE);
      /* redraw all affected ways */
      while(chain) {
-Line 2057 
 void map_delete_selected(appdata_t *appd
+Line 2026 
 void map_delete_selected(appdata_t *appd
          map_way_delete(appdata, chain->way);
        } else {
          map_item_t item;
-         item.type = MAP_TYPE_WAY;
+         item.object.type = WAY;
-         item.way = chain->way;
+         item.object.way = chain->way;
          map_item_redraw(appdata, &item);
        }
-Line 2069 
 void map_delete_selected(appdata_t *appd
+Line 2038 
 void map_delete_selected(appdata_t *appd
      break;
-   case MAP_TYPE_WAY:
+   case WAY:
-     printf("request to delete way #%ld\n", item.way->id);
+     printf("request to delete way #" ITEM_ID_FORMAT "\n", item.object.way->id);
-     map_way_delete(appdata, item.way);
+     map_way_delete(appdata, item.object.way);
      break;
    default:
-     g_assert((item.type == MAP_TYPE_NODE) ||
+     g_assert((item.object.type == NODE) ||
-              (item.type == MAP_TYPE_WAY));
+              (item.object.type == WAY));
      break;
    }
  }
  /* ----------------------- track related stuff ----------------------- */
+ static gboolean track_pos2lpos(bounds_t *bounds, pos_t *pos, lpos_t *lpos) {
+   pos2lpos(bounds, pos, lpos);
+   /* check if point is within bounds */
+   return ((lpos->x >= bounds->min.x) && (lpos->x <= bounds->max.x) &&
+           (lpos->y >= bounds->min.y) && (lpos->y <= bounds->max.y));
+ }
  void map_track_draw_seg(map_t *map, track_seg_t *seg) {
+   bounds_t *bounds = map->appdata->osm->bounds;
    /* a track_seg needs at least 2 points to be drawn */
    guint pnum = track_seg_points(seg);
    printf("seg of length %d\n", pnum);
-   if(pnum == 1) {
+   if(!pnum)
-     g_assert(!seg->item);
+     return;
-     seg->item = canvas_circle_new(map, CANVAS_GROUP_TRACK,
+   /* nothing should have been drawn by now ... */
-           seg->track_point->lpos.x, seg->track_point->lpos.y,
+   g_assert(!seg->item_chain);
-           map->style->track.width/2.0, 0, map->style->track.color, NO_COLOR);
-   }
+   track_item_chain_t **itemP = &seg->item_chain;
+   track_point_t *track_point = seg->track_point;
+   while(track_point) {
+     lpos_t lpos;
+     /* skip all points not on screen */
+     track_point_t *last = NULL;
+     while(track_point && !track_pos2lpos(bounds, &track_point->pos, &lpos)) {
+       last = track_point;
+       track_point = track_point->next;
+     }
+     int visible = 0;
+     /* count nodes that _are_ on screen */
+     track_point_t *tmp = track_point;
+     while(tmp && track_pos2lpos(bounds, &tmp->pos, &lpos)) {
+       tmp = tmp->next;
+       visible++;
+     }
+     /* actually start drawing with the last position that was offscreen */
+     /* so the track nicely enters the viewing area */
+     if(last) {
+       track_point = last;
+       visible++;
+     }
+     /* also use last one that's offscreen to nicely leave the visible area */
+     if(tmp && tmp->next)
+       visible++;
-   if(pnum > 1) {
      /* allocate space for nodes */
-     canvas_points_t *points = canvas_points_new(pnum);
+     canvas_points_t *points = canvas_points_new(visible);
-     int point = 0;
+     printf("visible are %d\n", visible);
-     track_point_t *track_point = seg->track_point;
+     int point;
-     while(track_point) {
+     for(point=0;point<visible;point++) {
-       points->coords[point++] = track_point->lpos.x;
+       track_pos2lpos(bounds, &track_point->pos, &lpos);
-       points->coords[point++] = track_point->lpos.y;
+       points->coords[2*point+0] = lpos.x;
+       points->coords[2*point+1] = lpos.y;
        track_point = track_point->next;
      }
-     /* there may be a circle (one point line) */
-     if(seg->item)
-       canvas_item_destroy(seg->item);
-     seg->item = canvas_polyline_new(map, CANVAS_GROUP_TRACK,
+     *itemP = g_new0(track_item_chain_t, 1);
-           points, map->style->track.width, map->style->track.color);
+     (*itemP)->item = canvas_polyline_new(map->canvas, CANVAS_GROUP_TRACK,
+                  points, map->style->track.width, map->style->track.color);
+     itemP = &(*itemP)->next;
      canvas_points_free(points);
    }
  }
+ /* update the last visible fragment of this segment since a */
+ /* gps position may have been added */
  void map_track_update_seg(map_t *map, track_seg_t *seg) {
+   bounds_t *bounds = map->appdata->osm->bounds;
+   printf("-- APPENDING TO TRACK --\n");
    /* a track_seg needs at least 2 points to be drawn */
    guint pnum = track_seg_points(seg);
    printf("seg of length %d\n", pnum);
-   if(pnum > 1) {
+   /* there are two cases: either the second last point was on screen */
+   /* or it wasn't. We'll have to start a new screen item if the latter */
+   /* is the case */
+   /* search last point */
+   track_point_t *begin = seg->track_point, *second_last = seg->track_point;
+   lpos_t lpos;
+   while(second_last && second_last->next && second_last->next->next) {
+     if(!track_pos2lpos(bounds, &second_last->pos, &lpos))
+       begin = second_last;
+     second_last = second_last->next;
+   }
+   track_point_t *last = second_last->next;
+   /* since we are updating an existing track, it sure has at least two */
+   /* points, second_last must be valid and its "next" (last) also */
+   g_assert(second_last);
+   g_assert(last);
+   /* check if the last and second_last points are visible */
+   gboolean last_is_visible =
+     track_pos2lpos(bounds, &last->pos, &lpos);
+   gboolean second_last_is_visible =
+     track_pos2lpos(bounds, &second_last->pos, &lpos);
+   /* if both are invisible, then nothing has changed on screen */
+   if(!last_is_visible && !second_last_is_visible) {
+     printf("second_last and last entry are invisible -> doing nothing\n");
+     return;
+   }
+   /* search last element in item chain */
+   track_item_chain_t *item = seg->item_chain;
+   while(item && item->next)
+     item = item->next;
+   if(second_last_is_visible) {
+     /* there must be something already on the screen and there must */
+     /* be visible nodes in the chain */
+     g_assert(item);
+     g_assert(begin);
+     printf("second_last is visible -> append\n");
-     /* allocate space for nodes */
+     /* count points to be placed */
-     canvas_points_t *points = canvas_points_new(pnum);
+     int npoints = 0;
+     track_point_t *tmp = begin;
+     while(tmp) {
+       tmp = tmp->next;
+       npoints++;
+     }
+     printf("updating last segment to %d points\n", npoints);
+     canvas_points_t *points = canvas_points_new(npoints);
+     gint point = 0;
+     while(begin) {
+       track_pos2lpos(bounds, &begin->pos, &lpos);
+       canvas_point_set_pos(points, point++, &lpos);
+       begin = begin->next;
+     }
-     int point = 0;
+     canvas_item_set_points(item->item, points);
-     track_point_t *track_point = seg->track_point;
+     canvas_points_free(points);
-     while(track_point) {
-       canvas_point_set_pos(points, point++, &track_point->lpos);
+   } else {
-       track_point = track_point->next;
+     printf("second last is invisible -> start new screen segment\n");
+     /* the search for the "begin" ends with the second_last item */
+     /* verify the last one also */
+     if(begin->next && !track_pos2lpos(bounds, &begin->next->pos, &lpos))
+       begin = begin->next;
+     item->next = g_new0(track_item_chain_t, 1);
+     item = item->next;
+     /* count points to be placed */
+     int npoints = 0;
+     track_point_t *tmp = begin;
+     while(tmp) {
+       tmp = tmp->next;
+       npoints++;
+     }
+     printf("attaching new segment with %d points\n", npoints);
+     canvas_points_t *points = canvas_points_new(npoints);
+     gint point = 0;
+     while(begin) {
+       track_pos2lpos(bounds, &begin->pos, &lpos);
+       canvas_point_set_pos(points, point++, &lpos);
+       begin = begin->next;
      }
-     g_assert(seg->item);
+     item->item = canvas_polyline_new(map->canvas, CANVAS_GROUP_TRACK,
-     canvas_item_set_points(seg->item, points);
+                  points, map->style->track.width, map->style->track.color);
      canvas_points_free(points);
    }
  }
  void map_track_draw(map_t *map, track_t *track) {
-Line 2163 
 void map_track_remove(appdata_t *appdata
+Line 2263 
 void map_track_remove(appdata_t *appdata
    /* remove all segments */
    track_seg_t *seg = track->track_seg;
    while(seg) {
-     if(seg->item) {
+     track_item_chain_t *item = seg->item_chain;
-       canvas_item_destroy(seg->item);
+     while(item) {
-       seg->item = NULL;
+       track_item_chain_t *next = item->next;
+       canvas_item_destroy(item->item);
+       item = next;
      }
+     seg->item_chain = NULL;
      seg = seg->next;
    }
  }
- void map_track_pos(appdata_t *appdata, lpos_t *lpos) {
+ void map_track_pos(appdata_t *appdata, pos_t *pos) {
    if(appdata->track.gps_item) {
      canvas_item_destroy(appdata->track.gps_item);
      appdata->track.gps_item = NULL;
    }
-   if(lpos)
+   if(pos) {
-     appdata->track.gps_item = canvas_circle_new(appdata->map, CANVAS_GROUP_GPS,
+     lpos_t lpos;
-         lpos->x, lpos->y, appdata->map->style->track.width/2.0, 0,
+     pos2lpos(appdata->osm->bounds, pos, &lpos);
-                         RGB2CANVAS(appdata->map->style->track.gps_color), NO_COLOR);
+     appdata->track.gps_item =
+       canvas_circle_new(appdata->map->canvas, CANVAS_GROUP_GPS,
+         lpos.x, lpos.y, appdata->map->style->track.width/2.0, 0,
+                         appdata->map->style->track.gps_color, NO_COLOR);
+   }
  }
  /* ------------------- map background ------------------ */
-Line 2222 
 void map_set_bg_image(map_t *map, char *
+Line 2330 
 void map_set_bg_image(map_t *map, char *
    map->bg.scale.y = (float)(bounds->max.y - bounds->min.y)/
      (float)gdk_pixbuf_get_height(map->bg.pix);
-   map->bg.item = canvas_image_new(map, CANVAS_GROUP_BG, map->bg.pix,
+   map->bg.item = canvas_image_new(map->canvas, CANVAS_GROUP_BG, map->bg.pix,
            bounds->min.x, bounds->min.y, map->bg.scale.x, map->bg.scale.y);
    canvas_item_destroy_connect(map->bg.item,
-Line 2236 
 void map_hide_selected(appdata_t *appdat
+Line 2344 
 void map_hide_selected(appdata_t *appdat
    map_t *map = appdata->map;
    if(!map) return;
-   if(map->selected.type != MAP_TYPE_WAY) {
+   if(map->selected.object.type != WAY) {
      printf("selected item is not a way\n");
      return;
    }
-   way_t *way = map->selected.way;
+   way_t *way = map->selected.object.way;
-   printf("hiding way #%ld\n", way->id);
+   printf("hiding way #" ITEM_ID_FORMAT "\n", way->id);
    map_item_deselect(appdata);
    way->flags |= OSM_FLAG_HIDDEN;
-Line 2267 
 void map_show_all(appdata_t *appdata) {
+Line 2375 
 void map_show_all(appdata_t *appdata) {
    gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
  }
+ static void map_detail_change(map_t *map, float detail) {
+   appdata_t *appdata = map->appdata;
+   /* deselecting anything allows us not to care about automatic deselection */
+   /* as well as items becoming invisible by the detail change */
+   map_item_deselect(appdata);
+   map->state->detail = detail;
+   printf("changing detail factor to %f\n", map->state->detail);
+   banner_busy_start(appdata, 1, _("Redrawing"));
+   map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
+   map_paint(appdata);
+   banner_busy_stop(appdata);
+ }
+ #define DETAIL_STEP 1.5
+ void map_detail_increase(map_t *map) {
+   if(!map) return;
+   map_detail_change(map, map->state->detail * DETAIL_STEP);
+ }
+ void map_detail_decrease(map_t *map) {
+   if(!map) return;
+   map_detail_change(map, map->state->detail / DETAIL_STEP);
+ }
+ void map_detail_normal(map_t *map) {
+   if(!map) return;
+   map_detail_change(map, 1.0);
+ }
  // vim:et:ts=8:sw=2:sts=2:ai

 Legend:



Removed from v.13
 


changed lines


 
Added in v.234
 Legend:



Removed from v.13
 


changed lines


 
Added in v.234
-Removed from v.13
+Added in v.234