Merge branch 'trunk' into aerostitch/commit-tipsaerostitch/commit-tips

5 files changed, 457 insertions, 70 deletions

diff --git a/navit/graphics/sdl/graphics_sdl.c b/navit/graphics/sdl/graphics_sdl.c
index 4187d4ed6..d92699307 100644
--- a/navit/graphics/sdl/graphics_sdl.c
+++ b/navit/graphics/sdl/graphics_sdl.c
@@ -284,45 +284,47 @@ static void image_free(struct graphics_priv *gr, struct graphics_image_priv * gi
     g_free(gi);
 }
 
-static void draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count) {
+static void draw_polygon_with_holes (struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count,
+                                     int hole_count, int* ccount, struct point **holes) {
+
+    dbg(lvl_debug, "draw_polygon_with_holes: %p ", gc);
     if ((gr->overlay_parent && !gr->overlay_parent->overlay_enable) || (gr->overlay_parent
             && gr->overlay_parent->overlay_enable && !gr->overlay_enable) ) {
         return;
     }
 
-    Sint16 *vx, *vy;
-    Sint16 x, y;
-    int i;
-
-    vx = alloca(count * sizeof(Sint16));
-    vy = alloca(count * sizeof(Sint16));
-
-    for(i = 0; i < count; i++) {
-        x = (Sint16)p[i].x;
-        y = (Sint16)p[i].y;
-        vx[i] = x;
-        vy[i] = y;
-
-        dbg(lvl_debug, "draw_polygon: %p %i %d,%d", gc, i, p[i].x, p[i].y);
-    }
+    /* SDL library (SDL_gfx) uses array of X and array of Y instead of array of points
+     * as the rest of navit does. This requires translating the coordinates from one struct
+     * into another. As we have our own version of SDL_gfx anyway, I step aside from this
+     * mechanic and continue using points. This breaks (pseudo= compatibility with stock
+     * sdl_graphics. Since we need to raytrace the polygons anyway, we can prepare the
+     * coordinates for SDL primitives there.
+     */
 
     if(gr->aa) {
-        raster_aapolygon(gr->screen, count, vx, vy,
-                         SDL_MapRGBA(gr->screen->format,
-                                     gc->fore_r,
-                                     gc->fore_g,
-                                     gc->fore_b,
-                                     gc->fore_a));
+        raster_aapolygon_with_holes(gr->screen, p, count, hole_count, ccount, holes,
+                                    SDL_MapRGBA(gr->screen->format,
+                                                gc->fore_r,
+                                                gc->fore_g,
+                                                gc->fore_b,
+                                                gc->fore_a));
     } else {
-        raster_polygon(gr->screen, count, vx, vy,
-                       SDL_MapRGBA(gr->screen->format,
-                                   gc->fore_r,
-                                   gc->fore_g,
-                                   gc->fore_b,
-                                   gc->fore_a));
+        raster_polygon_with_holes(gr->screen, p, count, hole_count, ccount, holes,
+                                  SDL_MapRGBA(gr->screen->format,
+                                              gc->fore_r,
+                                              gc->fore_g,
+                                              gc->fore_b,
+                                              gc->fore_a));
     }
 }
 
+static void draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count) {
+    dbg(lvl_debug, "draw_polygon: %p ", gc);
+    /* Use polygon with holes primitive as this seems to be better performing than the
+     * traditional SDL_gfx like ones */
+    draw_polygon_with_holes(gr, gc, p, count, 0, NULL, NULL);
+}
+
 static void draw_rectangle(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int w, int h) {
     if ((gr->overlay_parent && !gr->overlay_parent->overlay_enable) || (gr->overlay_parent
             && gr->overlay_parent->overlay_enable && !gr->overlay_enable) ) {
@@ -819,6 +821,8 @@ static struct graphics_methods graphics_methods = {
     NULL, /* set_attr */
     NULL, /* show_native_keyboard */
     NULL, /* hide_native_keyboard */
+    NULL, /* get_dpi */
+    draw_polygon_with_holes
 };
 
 static struct graphics_priv *overlay_new(struct graphics_priv *gr, struct graphics_methods *meth, struct point *p,
diff --git a/navit/graphics/sdl/raster.c b/navit/graphics/sdl/raster.c
index 6c713844b..8da7cd9a1 100644
--- a/navit/graphics/sdl/raster.c
+++ b/navit/graphics/sdl/raster.c
@@ -16,6 +16,7 @@
 
 
 #include <math.h>
+#include <glib.h>
 
 #include "raster.h"
 
@@ -1953,8 +1954,8 @@ void raster_aapolygon(SDL_Surface *dst, int16_t n, int16_t *vx, int16_t *vy, uin
                 o = p = -1;
             }
 #else
-
             raster_hline(dst, xa+1, xb, y, color);
+
 #endif
 
 //        raster_rect_inline(dst, xa, y, xb - xa, 1, color);
@@ -1962,3 +1963,199 @@ void raster_aapolygon(SDL_Surface *dst, int16_t n, int16_t *vx, int16_t *vy, uin
     }
 }
 
+/**
+ * @brief render filled polygon with holes by raycasting along the y axis
+ *
+ * This function renders a filled polygon that can have holes by SDL primitive
+ * graphic functions by raycasting along the y axis. This works basically the same
+ * as for complex polygons. Only difference is the "holes" are individual
+ * polygon loops not connected to the outer loop.
+ * FIXME: This draws well as long as the "hole" does not intersect with the
+ * outer polygon. However such multipolygons are seen a mapping error in OSM
+ * and therefore the rendering err may even help in detecting them.
+ * But this could be fixed by never starting a line on a vertex that came from a
+ * hole intersection.
+ *
+ * @param s SDL surface to draw on
+ * @param p Array of points containing the outer polygon
+ * @param count Number of points in outer polygon
+ * @param hole_count Number of hole polygons
+ * @param ccount number of points per hole polygon
+ * @oaram holes array of point arrays. One for each "hole"
+ * @param col Color to draw this.
+ */
+void raster_aapolygon_with_holes (SDL_Surface *s, struct point *p, int count, int hole_count, int* ccount,
+                                  struct point **holes, uint32_t col) {
+    int i;
+    struct point * p1;
+    struct point * p2;
+    /* Check visibility of clipping rectangle */
+    if ((s->clip_rect.w==0) || (s->clip_rect.h==0)) {
+        return;
+    }
+
+    /* Sanity check number of edges */
+    if (count < 3) {
+        return;
+    }
+    /*
+     * Draw antialiased outline
+     */
+    p1 = p2 = p;
+    p2++;
+    for (i = 1; i < count; i++) {
+        raster_aalineColorInt(s, p1->x, p1->y, p2->x, p2->y, col, 0);
+        p1 = p2;
+        p2++;
+    }
+    raster_aalineColorInt(s, p1->x, p1->y, p->x, p->y, col, 0);
+    raster_polygon_with_holes(s, p, count, hole_count, ccount, holes, col);
+}
+
+/**
+ * @brief render filled polygon with holes by raycasting along the y axis
+ *
+ * This function renders a filled polygon that can have holes by SDL primitive
+ * graphic functions by raycasting along the y axis. This works basically the same
+ * as for complex polygons. Only difference is the "holes" are individual
+ * polygon loops not connected to the outer loop.
+ * FIXME: This draws well as long as the "hole" does not intersect with the
+ * outer polygon. However such multipolygons are seen a mapping error in OSM
+ * and therefore the rendering err may even help in detecting them.
+ * But this could be fixed by never starting a line on a vertex that came from a
+ * hole intersection.
+ *
+ * @param s SDL surface to draw on
+ * @param p Array of points containing the outer polygon
+ * @param count Number of points in outer polygon
+ * @param hole_count Number of hole polygons
+ * @param ccount number of points per hole polygon
+ * @oaram holes array of point arrays. One for each "hole"
+ * @param col Color to draw this.
+ */
+void raster_polygon_with_holes (SDL_Surface *s, struct point *p, int count, int hole_count, int* ccount,
+                                struct point **holes, uint32_t col) {
+    int vertex_max;
+    int vertex_count;
+    int * vertexes;
+    int miny, maxy;
+    int i;
+    int y;
+
+    /* Check visibility of clipping rectangle */
+    if ((s->clip_rect.w==0) || (s->clip_rect.h==0)) {
+        return;
+    }
+
+    /* Sanity check number of edges */
+    if (count < 3) {
+        return;
+    }
+
+    /*
+     * Prepare a buffer for vertexes. Maximum number of vertexes is the number of points
+     * of polygon and holes
+     */
+    vertex_max = count;
+    for(i =0; i < hole_count; i ++) {
+        vertex_max += ccount[i];
+    }
+    vertexes = g_malloc(sizeof(int) * vertex_max);
+    if(vertexes == NULL) {
+        return;
+    }
+
+    /* calculate y min and max coordinate. We can ignore the holes, as we won't render hole
+     * parts "bigger" than the surrounding polygon.*/
+    miny = p[0].y;
+    maxy = p[0].y;
+    for (i = 1; (i < count); i++) {
+        if (p[i].y < miny) {
+            miny = p[i].y;
+        } else if (p[i].y > maxy) {
+            maxy = p[i].y;
+        }
+    }
+
+    /* scan y coordinates from miny to maxy */
+    for(y = miny; y <= maxy ; y ++) {
+        int h;
+        vertex_count=0;
+        /* calculate the intersecting points of the polygon with current y and add to vertexes array*/
+        for (i = 0; (i < count); i++) {
+            int ind1;
+            int ind2;
+            struct point p1;
+            struct point p2;
+
+            if (!i) {
+                ind1 = count - 1;
+                ind2 = 0;
+            } else {
+                ind1 = i - 1;
+                ind2 = i;
+            }
+            p1.y = p[ind1].y;
+            p2.y = p[ind2].y;
+            if (p1.y < p2.y) {
+                p1.x = p[ind1].x;
+                p2.x = p[ind2].x;
+            } else if (p1.y > p2.y) {
+                p2.y = p[ind1].y;
+                p1.y = p[ind2].y;
+                p2.x = p[ind1].x;
+                p1.x = p[ind2].x;
+            } else {
+                continue;
+            }
+            if ( ((y >= p1.y) && (y < p2.y)) || ((y == maxy) && (y > p1.y) && (y <= p2.y)) ) {
+                vertexes[vertex_count++] = ((65536 * (y - p1.y)) / (p2.y - p1.y)) * (p2.x - p1.x) + (65536 * p1.x);
+            }
+        }
+        for(h= 0; h < hole_count; h ++) {
+            /* add the intersecting points from the holes as well */
+            for (i = 0; (i < ccount[h]); i++) {
+                int ind1;
+                int ind2;
+                struct point p1;
+                struct point p2;
+
+                if (!i) {
+                    ind1 = ccount[h] - 1;
+                    ind2 = 0;
+                } else {
+                    ind1 = i - 1;
+                    ind2 = i;
+                }
+                p1.y = holes[h][ind1].y;
+                p2.y = holes[h][ind2].y;
+                if (p1.y < p2.y) {
+                    p1.x = holes[h][ind1].x;
+                    p2.x = holes[h][ind2].x;
+                } else if (p1.y > p2.y) {
+                    p2.y = holes[h][ind1].y;
+                    p1.y = holes[h][ind2].y;
+                    p2.x = holes[h][ind1].x;
+                    p1.x = holes[h][ind2].x;
+                } else {
+                    continue;
+                }
+                if ( ((y >= p1.y) && (y < p2.y)) || ((y == maxy) && (y > p1.y) && (y <= p2.y)) ) {
+                    vertexes[vertex_count++] = ((65536 * (y - p1.y)) / (p2.y - p1.y)) * (p2.x - p1.x) + (65536 * p1.x);
+                }
+            }
+        }
+
+        /* sort the vertexes */
+        qsort(vertexes, vertex_count, sizeof(int), gfxPrimitivesCompareInt);
+        /* draw the lines between every second vertex */
+        for (i = 0; (i < vertex_count); i +=2) {
+            Sint16 xa;
+            Sint16 xb;
+            xa = (vertexes[i] >> 16);
+            xb = (vertexes[i+1] >> 16);
+            raster_hline(s, xa+1, xb, y, col);
+        }
+    }
+    g_free(vertexes);
+}
diff --git a/navit/graphics/sdl/raster.h b/navit/graphics/sdl/raster.h
index 2e68ea05f..e295f23fb 100644
--- a/navit/graphics/sdl/raster.h
+++ b/navit/graphics/sdl/raster.h
@@ -10,15 +10,21 @@
 
 #include <stdint.h>
 #include "SDL.h"
+#include "point.h"
 
 void raster_rect(SDL_Surface *s, int16_t x, int16_t y, int16_t w, int16_t h, uint32_t col);
 
 void raster_line(SDL_Surface *s, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t col);
 void raster_circle(SDL_Surface *s, int16_t x, int16_t y, int16_t r, uint32_t col);
 void raster_polygon(SDL_Surface *s, int16_t n, int16_t *vx, int16_t *vy, uint32_t col);
+void raster_polygon_with_holes (SDL_Surface *s, struct point *p, int count, int hole_count, int* ccount,
+                                struct point **holes, uint32_t col);
 
 void raster_aaline(SDL_Surface *s, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t col);
 void raster_aacircle(SDL_Surface *s, int16_t x, int16_t y, int16_t r, uint32_t col);
 void raster_aapolygon(SDL_Surface *s, int16_t n, int16_t *vx, int16_t *vy, uint32_t col);
+void raster_aapolygon_with_holes (SDL_Surface *s, struct point *p, int count, int hole_count, int* ccount,
+                                  struct point **holes, uint32_t col);
+
 
 #endif /* __RASTER_H */
diff --git a/navit/graphics/win32/graphics_win32.c b/navit/graphics/win32/graphics_win32.c
index 6bcad3be6..6346e59f7 100644
--- a/navit/graphics/win32/graphics_win32.c
+++ b/navit/graphics/win32/graphics_win32.c
@@ -829,8 +829,177 @@ static void draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc,
 
 #if HAVE_API_WIN32_CE
 /*
- * Windows CE doesn't support PaintPath used for other versions. No polygon with holes support for CE yet.
+ * Windows CE doesn't feature GraphicsPath, so in order to draw filled polygons
+ * with holes, we need to resort on manual raycasting. The following functions
+ * have been inspired from SDL backend that does need to raycast all polygons.
  */
+
+/* Helper qsort callback for polygon drawing */
+static int gfxPrimitivesCompareInt(const void *a, const void *b) {
+    return (*(const int *) a) - (*(const int *) b);
+}
+
+/**
+ * @brief render filled polygon with holes by raycasting along the y axis
+ *
+ * This function renders a filled polygon that can have holes by SDL primitive
+ * graphic functions by raycasting along the y axis. This works basically the same
+ * as for complex polygons. Only difference is the "holes" are individual
+ * polygon loops not connected to the outer loop.
+ * FIXME: This draws well as long as the "hole" does not intersect with the
+ * outer polygon. However such multipolygons are seen a mapping error in OSM
+ * and therefore the rendering err may even help in detecting them.
+ * But this could be fixed by never starting a line on a vertex that came from a
+ * hole intersection.
+ *
+ * @param gr graphics instance
+ * @param gc graphics context
+ * @param p Array of points for the outer polygon
+ * @param count Number of points in outer polygon
+ * @param hole_count Number of hole polygons
+ * @param ccount number of points per hole polygon
+ * @oaram holes array of point arrays. One for each "hole"
+ */
+static void draw_polygon_with_holes (struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count,
+                                     int hole_count, int* ccount, struct point **holes) {
+    int vertex_max;
+    int vertex_count;
+    int * vertexes;
+    int miny, maxy;
+    int i;
+    int y;
+    HPEN holdpen;
+    HBRUSH holdbrush;
+    HPEN linepen;
+
+    /* Sanity check number of edges */
+    if (count < 3) {
+        return;
+    }
+
+    /*
+     * Prepare a buffer for vertexes. Maximum number of vertexes is the number of points
+     * of polygon and holes
+     */
+    vertex_max = count;
+    for(i =0; i < hole_count; i ++) {
+        vertex_max += ccount[i];
+    }
+    vertexes = g_malloc(sizeof(int) * vertex_max);
+    if(vertexes == NULL) {
+        return;
+    }
+
+    /* create pen to draw the lines */
+    linepen = CreatePen( PS_SOLID, 1, gc->fg_color );
+
+    /* remeber pen and brush */
+    holdpen = SelectObject( gr->hMemDC, linepen );
+    holdbrush = SelectObject( gr->hMemDC, gc->hbrush );
+
+    /* calculate y min and max coordinate. We can ignore the holes, as we won't render hole
+     * parts "bigger" than the surrounding polygon.*/
+    miny = p[0].y;
+    maxy = p[0].y;
+    for (i = 1; (i < count); i++) {
+        if (p[i].y < miny) {
+            miny = p[i].y;
+        } else if (p[i].y > maxy) {
+            maxy = p[i].y;
+        }
+    }
+
+    /* scan y coordinates from miny to maxy */
+    for(y = miny; y <= maxy ; y ++) {
+        int h;
+        vertex_count=0;
+        /* calculate the intersecting points of the polygon with current y and add to vertexes array*/
+        for (i = 0; (i < count); i++) {
+            int ind1;
+            int ind2;
+            struct point p1;
+            struct point p2;
+
+            if (!i) {
+                ind1 = count - 1;
+                ind2 = 0;
+            } else {
+                ind1 = i - 1;
+                ind2 = i;
+            }
+            p1.y = p[ind1].y;
+            p2.y = p[ind2].y;
+            if (p1.y < p2.y) {
+                p1.x = p[ind1].x;
+                p2.x = p[ind2].x;
+            } else if (p1.y > p2.y) {
+                p2.y = p[ind1].y;
+                p1.y = p[ind2].y;
+                p2.x = p[ind1].x;
+                p1.x = p[ind2].x;
+            } else {
+                continue;
+            }
+            if ( ((y >= p1.y) && (y < p2.y)) || ((y == maxy) && (y > p1.y) && (y <= p2.y)) ) {
+                vertexes[vertex_count++] = ((65536 * (y - p1.y)) / (p2.y - p1.y)) * (p2.x - p1.x) + (65536 * p1.x);
+            }
+        }
+        for(h= 0; h < hole_count; h ++) {
+            /* add the intersecting points from the holes as well */
+            for (i = 0; (i < ccount[h]); i++) {
+                int ind1;
+                int ind2;
+                struct point p1;
+                struct point p2;
+
+                if (!i) {
+                    ind1 = ccount[h] - 1;
+                    ind2 = 0;
+                } else {
+                    ind1 = i - 1;
+                    ind2 = i;
+                }
+                p1.y = holes[h][ind1].y;
+                p2.y = holes[h][ind2].y;
+                if (p1.y < p2.y) {
+                    p1.x = holes[h][ind1].x;
+                    p2.x = holes[h][ind2].x;
+                } else if (p1.y > p2.y) {
+                    p2.y = holes[h][ind1].y;
+                    p1.y = holes[h][ind2].y;
+                    p2.x = holes[h][ind1].x;
+                    p1.x = holes[h][ind2].x;
+                } else {
+                    continue;
+                }
+                if ( ((y >= p1.y) && (y < p2.y)) || ((y == maxy) && (y > p1.y) && (y <= p2.y)) ) {
+                    vertexes[vertex_count++] = ((65536 * (y - p1.y)) / (p2.y - p1.y)) * (p2.x - p1.x) + (65536 * p1.x);
+                }
+            }
+        }
+
+        /* sort the vertexes */
+        qsort(vertexes, vertex_count, sizeof(int), gfxPrimitivesCompareInt);
+        /* draw the lines between every second vertex */
+        for (i = 0; (i < vertex_count); i +=2) {
+            int xa;
+            int xb;
+            xa = (vertexes[i] >> 16);
+            xb = (vertexes[i+1] >> 16);
+            MoveToEx( gr->hMemDC, xa+1, y, NULL );
+            LineTo( gr->hMemDC, xb, y );
+        }
+    }
+    /* free vertex buffer */
+    g_free(vertexes);
+
+    /* restore pen and brush */
+    SelectObject( gr->hMemDC, holdbrush);
+    SelectObject( gr->hMemDC, holdpen);
+
+    /* delete linepen */
+    DeleteObject(linepen);
+}
 #else
 static void draw_polygon_with_holes (struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count,
                                      int hole_count, int* ccount, struct point **holes) {
@@ -1522,11 +1691,7 @@ static struct graphics_methods graphics_methods = {
     NULL, /* show_native_keyboard */
     NULL, /* hide_native_keyboard */
     NULL, /* get dpi */
-#if HAVE_API_WIN32_CE
-    NULL, /* draw_polygon_with_holes */
-#else
     draw_polygon_with_holes
-#endif
 };
 
 
diff --git a/navit/maptool/osm.c b/navit/maptool/osm.c
index 6fd05674d..caba43e94 100644
--- a/navit/maptool/osm.c
+++ b/navit/maptool/osm.c
@@ -138,7 +138,22 @@ char *osm_types[]= {"unknown","node","way","relation"};
 struct country_table {
     int countryid;
     char *names;
-    char *admin_levels;
+    char *admin_levels; /**<
+                         * String indicating how to interpret admin levels for this country.
+                         *
+                         * Each character of the string specifies how to treat the corresponding admin level.
+                         * The first character corresponds to level 3, each following character to the next
+                         * lower level (usually up to level 8, but that is just a convention):
+                         * `s`: use the name as the state label, `c`: use the name as the county label,
+                         * `m`: use the name as the municipality label, `M`: same as `m`, but additionally
+                         * use the boundary as the town boundary, `T`: use the boundary the town boundary and
+                         * ignore the name. All other characters are ignored; by convention use the digit
+                         * corresponding to the admin level to indicate this level should be skipped.
+                         *
+                         * See
+                         * https://wiki.openstreetmap.org/wiki/Tag:boundary%3Dadministrative#10_admin_level_values_for_specific_countries
+                         * for values used in specific countries.
+                         */
     FILE *file;
     int size;
     struct rect r;
@@ -154,8 +169,8 @@ struct country_table {
     { 28,"Antigua and Barbuda"},
     { 31,"Azerbaijan"},
     { 32,"Argentina,República Argentina,AR "},
-    { 36,"Australia,AUS"},
-    { 40,"Austria,Österreich,AUT"},
+    { 36,"Australia,AUS","3s456c8"},
+    { 40,"Austria,Österreich,AUT","3s5c78"},
     { 44,"Bahamas"},
     { 48,"Bahrain"},
     { 50,"Bangladesh"},
@@ -168,19 +183,19 @@ struct country_table {
     { 70,"Bosnia and Herzegovina,Bosna i Hercegovina,Босна и Херцеговина"},
     { 72,"Botswana"},
     { 74,"Bouvet Island"},
-    { 76,"Brazil"},
+    { 76,"Brazil","3s5cm8"},
     { 84,"Belize"},
     { 86,"British Indian Ocean Territory"},
     { 90,"Solomon Islands"},
     { 92,"Virgin Islands, British"},
     { 96,"Brunei Darussalam"},
-    { 100,"Bulgaria,България"},
+    { 100,"Bulgaria,България","3s5cm8"},
     { 104,"Myanmar"},
     { 108,"Burundi"},
-    { 112,"Belarus"},
+    { 112,"Belarus","3s5c78"},
     { 116,"Cambodia"},
     { 120,"Cameroon"},
-    { 124,"Canada"},
+    { 124,"Canada","3scm78"},
     { 132,"Cape Verde"},
     { 136,"Cayman Islands"},
     { 140,"Central African Republic"},
@@ -198,12 +213,12 @@ struct country_table {
     { 180,"Congo, the Democratic Republic of the"},
     { 184,"Cook Islands"},
     { 188,"Costa Rica"},
-    { 191,"Croatia,Republika Hrvatska,HR"},
+    { 191,"Croatia,Republika Hrvatska,HR","34scm8"},
     { 192,"Cuba"},
-    { 196,"Cyprus"},
-    { 203,"Czech Republic,Česká republika,CZ"},
+    { 196,"Cyprus","345c7m"},
+    { 203,"Czech Republic,Česká republika,CZ","345cm8"},
     { 204,"Benin"},
-    { 208,"Denmark,Danmark,DK"},
+    { 208,"Denmark,Danmark,DK","3c56m8"},
     { 212,"Dominica"},
     { 214,"Dominican Republic"},
     { 218,"Ecuador"},
@@ -211,12 +226,12 @@ struct country_table {
     { 226,"Equatorial Guinea"},
     { 231,"Ethiopia"},
     { 232,"Eritrea"},
-    { 233,"Estonia"},
+    { 233,"Estonia,Eesti","345cm8"},
     { 234,"Faroe Islands,Føroyar"},
     { 238,"Falkland Islands (Malvinas)"},
     { 239,"South Georgia and the South Sandwich Islands"},
     { 242,"Fiji"},
-    { 246,"Finland,Suomi"},
+    { 246,"Finland,Suomi","3s5cm8"},
     { 248,"Åland Islands"},
     { 250,"France,République française,FR","3s5c7M"},
     { 254,"French Guiana"},
@@ -224,10 +239,10 @@ struct country_table {
     { 260,"French Southern Territories"},
     { 262,"Djibouti"},
     { 266,"Gabon"},
-    { 268,"Georgia"},
+    { 268,"Georgia","3s5c78"},
     { 270,"Gambia"},
     { 275,"Palestinian Territory, Occupied"},
-    { 276,"Germany,Deutschland,Bundesrepublik Deutschland","345c7M"},
+    { 276,"Germany,Deutschland,Bundesrepublik Deutschland","3s5c7M"},
     { 288,"Ghana"},
     { 292,"Gibraltar"},
     { 296,"Kiribati"},
@@ -244,35 +259,35 @@ struct country_table {
     { 336,"Holy See (Vatican City State)"},
     { 340,"Honduras"},
     { 344,"Hong Kong"},
-    { 348,"Hungary,Magyarország"},
-    { 352,"Iceland"},
-    { 356,"India"},
+    { 348,"Hungary,Magyarország","345c78"},
+    { 352,"Iceland","34cm78"},
+    { 356,"India","3sc6m8"},
     { 360,"Indonesia"},
     { 364,"Iran, Islamic Republic of"},
     { 368,"Iraq"},
-    { 372,"Ireland"},
+    { 372,"Ireland","345c78"},
     { 376,"Israel"},
-    { 380,"Italy,Italia"},
+    { 380,"Italy,Italia","3s5c78"},
     { 384,"Côte d'Ivoire"},
     { 388,"Jamaica"},
-    { 392,"Japan"},
+    { 392,"Japan","3s5cm8"},
     { 398,"Kazakhstan"},
     { 400,"Jordan"},
     { 404,"Kenya"},
-    { 408,"Korea, Democratic People's Republic of"},
-    { 410,"Korea, Republic of"},
+    { 408,"Korea, Democratic People's Republic of","3s5cm8"},
+    { 410,"Korea, Republic of","3s5cm8"},
     { 412,"Kosovo,Kosova"},
     { 414,"Kuwait"},
     { 417,"Kyrgyzstan"},
     { 418,"Lao People's Democratic Republic"},
     { 422,"Lebanon"},
     { 426,"Lesotho"},
-    { 428,"Latvia"},
+    { 428,"Latvia,Latvija","345c78"},
     { 430,"Liberia"},
     { 434,"Libyan Arab Jamahiriya"},
     { 438,"Liechtenstein"},
-    { 440,"Lithuania,Lietuva"},
-    { 442,"Luxembourg"},
+    { 440,"Lithuania,Lietuva","3cm67T"},
+    { 442,"Luxembourg","3s5c78"},
     { 446,"Macao"},
     { 450,"Madagascar"},
     { 454,"Malawi"},
@@ -283,7 +298,7 @@ struct country_table {
     { 474,"Martinique"},
     { 478,"Mauritania"},
     { 480,"Mauritius"},
-    { 484,"Mexico"},
+    { 484,"Mexico","3s5m78"},
     { 492,"Monaco"},
     { 496,"Mongolia"},
     { 498,"Moldova, Republic of"},
@@ -303,13 +318,13 @@ struct country_table {
     { 535,"Bonaire, Sint Eustatius and Saba"},
     { 540,"New Caledonia"},
     { 548,"Vanuatu"},
-    { 554,"New Zealand"},
+    { 554,"New Zealand","3s5m78"},
     { 558,"Nicaragua"},
     { 562,"Niger"},
     { 566,"Nigeria"},
     { 570,"Niue"},
     { 574,"Norfolk Island"},
-    { 578,"Norway,Norge,Noreg,NO"},
+    { 578,"Norway,Norge,Noreg,NO","3c56m8"},
     { 580,"Northern Mariana Islands"},
     { 581,"United States Minor Outlying Islands"},
     { 583,"Micronesia, Federated States of"},
@@ -323,13 +338,13 @@ struct country_table {
     { 608,"Philippines"},
     { 612,"Pitcairn"},
     { 616,"Poland,Polska,PL","3s5cmT"},
-    { 620,"Portugal"},
+    { 620,"Portugal","345cm8"},
     { 624,"Guinea-Bissau"},
     { 626,"Timor-Leste"},
     { 630,"Puerto Rico"},
     { 634,"Qatar"},
     { 638,"Réunion"},
-    { 642,"România,Romania,RO"},
+    { 642,"România,Romania,RO","sc5m78"},
     { 643,"Россия,Российская Федерация,Russia,Russian Federation","3s5c7m"},
     { 646,"Rwanda"},
     { 652,"Saint Barthélemy"},
@@ -344,13 +359,13 @@ struct country_table {
     { 678,"Sao Tome and Principe"},
     { 682,"Saudi Arabia"},
     { 686,"Senegal"},
-    { 688,"Srbija,Србија,Serbia"},
+    { 688,"Srbija,Србија,Serbia","3scm78"},
     { 690,"Seychelles"},
     { 694,"Sierra Leone"},
     { 702,"Singapore"},
-    { 703,"Slovakia,Slovensko,SK"},
+    { 703,"Slovakia,Slovensko,SK","3c567m"},
     { 704,"Viet Nam"},
-    { 705,"Slovenia,Republika Slovenija,SI"},
+    { 705,"Slovenia,Republika Slovenija,SI","34s6cm"},
     { 706,"Somalia"},
     { 710,"South Africa"},
     { 716,"Zimbabwe"},
@@ -361,7 +376,7 @@ struct country_table {
     { 740,"Suriname"},
     { 744,"Svalbard and Jan Mayen"},
     { 748,"Swaziland"},
-    { 752,"Sweden,Sverige,Konungariket Sverige,SE"},
+    { 752,"Sweden,Sverige,Konungariket Sverige,SE","3c56m8"},
     { 756,"Switzerland,Schweiz","3s5c7M"},
     { 760,"Syrian Arab Republic"},
     { 762,"Tajikistan"},
@@ -372,7 +387,7 @@ struct country_table {
     { 780,"Trinidad and Tobago"},
     { 784,"United Arab Emirates"},
     { 788,"Tunisia"},
-    { 792,"Turkey"},
+    { 792,"Turkey","sc5m78"},
     { 795,"Turkmenistan"},
     { 796,"Turks and Caicos Islands"},
     { 798,"Tuvalu"},