Ticket #12: navit_imperial_mph.patch

File navit_imperial_mph.patch, 9.4 KB (added by hoorah, 12 years ago)
  • navit/navit/osd/core/osd_core.c

     
    9797}
    9898
    9999static char *
    100 format_distance(double distance, char *sep)
     100format_distance(double distance, char *sep, int imperial)
    101101{
    102         if (distance >= 100000)
    103                 return g_strdup_printf("%.0f%skm", distance / 1000, sep);
    104         else if (distance >= 10000)
    105                 return g_strdup_printf("%.1f%skm", distance / 1000, sep);
    106         else if (distance >= 300)
    107                 return g_strdup_printf("%.0f%sm", round(distance / 25) * 25, sep);
    108         else if (distance >= 50)
    109                 return g_strdup_printf("%.0f%sm", round(distance / 10) * 10, sep);
    110         else if (distance >= 10)
    111                 return g_strdup_printf("%.0f%sm", distance, sep);
    112         else
    113                 return g_strdup_printf("%.1f%sm", distance, sep);
     102        if (!strcmp(sep,"US")){
     103                distance *= FEET_PER_METER;
     104                if(distance <= 1500){
     105                        return g_strdup_printf("%.0f%sft", round(distance / 10) * 10 );
     106                } else {
     107                        return g_strdup_printf("%.1f%smi", distance / FEET_PER_MILE );
     108                }
     109        } else {
     110                if (distance >= 100000)
     111                        return g_strdup_printf("%.0f%skm", distance / 1000, sep);
     112                else if (distance >= 10000)
     113                        return g_strdup_printf("%.1f%skm", distance / 1000, sep);
     114                else if (distance >= 300)
     115                        return g_strdup_printf("%.0f%sm", round(distance / 25) * 25, sep);
     116                else if (distance >= 50)
     117                        return g_strdup_printf("%.0f%sm", round(distance / 10) * 10, sep);
     118                else if (distance >= 10)
     119                        return g_strdup_printf("%.0f%sm", distance, sep);
     120                else
     121                        return g_strdup_printf("%.1f%sm", distance, sep);
     122        }
    114123}
    115124
    116125static char *
     
    123132}
    124133
    125134static char *
    126 format_speed(double speed, char *sep)
     135format_speed(double speed, char *sep, int imperial)
    127136{
     137        if (imperial){
     138                speed *= 1000 * FEET_PER_METER;
     139                return g_strdup_printf("%.0f%smph", speed / FEET_PER_MILE, sep);
     140        }
    128141        return g_strdup_printf("%.0f%skm/h", speed, sep);
    129142}
    130143
     
    145158                 struct vehicle *v)
    146159{
    147160        struct point p,bbox[4];
    148         struct attr attr_dir, destination_attr, position_attr;
     161        struct attr attr_dir, destination_attr, position_attr, imperial_attr;
    149162        double dir, vdir = 0;
    150163        char *buffer;
    151164        struct coord c1, c2;
     
    171184                        dir = atan2(c2.x - c1.x, c2.y - c1.y) * 180.0 / M_PI;
    172185                        dir -= vdir;
    173186                        handle(this->osd_item.gr, this->green, &p, this->osd_item.w/3, dir);
    174                         buffer=format_distance(transform_distance(pro, &c1, &c2),"");
     187                        buffer=format_distance(transform_distance(pro, &c1, &c2),"",navit_get_attr(nav, attr_imperial, &imperial_attr, NULL));
    175188                        graphics_get_text_bbox(this->osd_item.gr, this->osd_item.font, buffer, 0x10000, 0, bbox, 0);
    176189                        p.x=(this->osd_item.w-bbox[2].x)/2;
    177190                        p.y = this->osd_item.h-this->osd_item.h/10;
     
    656669
    657670        switch (attr->type) {
    658671        case attr_position_speed:
    659                 return format_speed(*attr->u.numd,"");
     672                if(!strcmp(format,"miles")){
     673                        return format_speed(*attr->u.numd,"",1);
     674                }
     675                return format_speed(*attr->u.numd,"",0);
    660676        case attr_position_height:
    661677        case attr_position_direction:
    662678                return format_float_0(*attr->u.numd);
     
    692708                if (!format)
    693709                        break;
    694710                if (!strcmp(format,"named"))
    695                         return format_distance(attr->u.num,"");
     711                        return format_distance(attr->u.num,"",0);
     712                if(!strcmp(format,"miles")){
     713                        return format_distance(attr->u.num,"",1);
     714                }
    696715                if (!strcmp(format,"value") || !strcmp(format,"unit")) {
    697                         char *ret,*tmp=format_distance(attr->u.num," ");
     716                        char *ret,*tmp=format_distance(attr->u.num," ",0);
    698717                        char *pos=strchr(tmp,' ');
    699718                        if (! pos)
    700719                                return tmp;
     
    823842                                        item=tracking_get_current_item(tracking);
    824843                                        if (item && !strcmp(key,"route_speed")) {
    825844                                                double routespeed = -1;
     845                                                struct attr imperial_attr;
     846                                                int imperial = navit_get_attr(navit, attr_imperial, &imperial_attr, NULL);
    826847                                                int *flags=tracking_get_current_flags(tracking);
    827848                                                if (flags && (*flags & AF_SPEED_LIMIT) && tracking_get_attr(tracking, attr_maxspeed, &maxspeed_attr, NULL)) {
    828849                                                        routespeed = maxspeed_attr.u.num;
    829                                                         value = format_speed(routespeed, "");
     850                                                        value = format_speed(routespeed,"",imperial);
    830851                                                }
    831852
    832853                                                if (routespeed == -1) {
     
    836857                                                                rprof=vehicleprofile_get_roadprofile(prof, item->type);
    837858                                                        if (rprof) {
    838859                                                                routespeed=rprof->speed;
    839                                                                 value=format_speed(routespeed,"");
     860                                                                value=format_speed(routespeed,"",imperial);
    840861                                                        }
    841862                                                }
    842863                                        }
  • navit/navit/attr_def.h

     
    106106ATTR(message_maxage)
    107107ATTR(message_maxnum)
    108108ATTR(pitch)
     109ATTR(imperial)
    109110ATTR(roll)
    110111ATTR(yaw)
    111112ATTR(route_status)
  • navit/navit/navigation.c

     
    307307}
    308308
    309309static char *
    310 get_distance(int dist, enum attr_type type, int is_length)
     310get_distance(struct navigation *nav, int dist, enum attr_type type, int is_length)
    311311{
    312         if (type == attr_navigation_long) {
    313                 if (is_length)
    314                         return g_strdup_printf(_("%d m"), dist);
     312        int dist_ft, dist_mi;
     313        struct attr attr;
     314
     315        navit_get_attr(nav->navit, attr_imperial, &attr, NULL);
     316        if (attr.u.num == 1)  {
     317
     318                dist_ft = dist * FEET_PER_METER;
     319                dist_mi = dist_ft / FEET_PER_MILE;
     320                if (dist_ft < 1000) {
     321                        if (is_length)
     322                                return g_strdup_printf(_("%d feet"), dist_ft);
     323                        else
     324                                return g_strdup_printf(_("in %d feet"), dist_ft);
     325                }
     326                if (dist_ft < 5000) {
     327                        int rem=(dist_ft/528)%10;
     328                        if (rem) {
     329                                if (is_length)
     330                                        return g_strdup_printf(_("%d.%d miles"), dist_mi, rem);
     331                                else
     332                                        return g_strdup_printf(_("in %d.%d miles"), dist_mi, rem);
     333                        }
     334                }
     335                if (is_length)
     336                        return g_strdup_printf(ngettext("one mile","%d miles", dist_mi), dist_mi);
    315337                else
    316                         return g_strdup_printf(_("in %d m"), dist);
    317         }
    318         if (dist < 1000) {
    319                 if (is_length)
    320                         return g_strdup_printf(_("%d meters"), dist);
    321                 else
    322                         return g_strdup_printf(_("in %d meters"), dist);
    323         }
    324         if (dist < 5000) {
    325                 int rem=(dist/100)%10;
    326                 if (rem) {
     338                        return g_strdup_printf(ngettext("in one mile","in %d miles", dist_mi), dist_mi);
     339
     340
     341        } else {
     342
     343                if (type == attr_navigation_long) {
    327344                        if (is_length)
    328                                 return g_strdup_printf(_("%d.%d kilometer"), dist/1000, rem);
     345                                return g_strdup_printf(_("%d m"), dist);
    329346                        else
    330                                 return g_strdup_printf(_("in %d.%d kilometers"), dist/1000, rem);
     347                                return g_strdup_printf(_("in %d m"), dist);
    331348                }
     349                if (dist < 1000) {
     350                        if (is_length)
     351                                return g_strdup_printf(_("%d meters"), dist);
     352                        else
     353                                return g_strdup_printf(_("in %d meters"), dist);
     354                }
     355                if (dist < 5000) {
     356                        int rem=(dist/100)%10;
     357                        if (rem) {
     358                                if (is_length)
     359                                        return g_strdup_printf(_("%d.%d kilometer"), dist/1000, rem);
     360                                else
     361                                        return g_strdup_printf(_("in %d.%d kilometers"), dist/1000, rem);
     362                        }
     363                }
     364                if (is_length)
     365                        return g_strdup_printf(ngettext("one kilometer","%d kilometers", dist/1000), dist/1000);
     366                else
     367                        return g_strdup_printf(ngettext("in one kilometer","in %d kilometers", dist/1000), dist/1000);
    332368        }
    333         if (is_length)
    334                 return g_strdup_printf(ngettext("one kilometer","%d kilometers", dist/1000), dist/1000);
    335         else
    336                 return g_strdup_printf(ngettext("in one kilometer","in %d kilometers", dist/1000), dist/1000);
    337369}
    338370
    339371
     
    14121444                case 2:
    14131445                        return g_strdup(_("Enter the roundabout soon"));
    14141446                case 1:
    1415                         d = get_distance(distance, type, 1);
     1447                        d = get_distance(nav, distance, type, 1);
    14161448                        /* TRANSLATORS: %s is the distance to the roundabout */
    14171449                        ret = g_strdup_printf(_("In %s, enter the roundabout"), d);
    14181450                        g_free(d);
     
    14411473
    14421474        switch(level) {
    14431475        case 3:
    1444                 d=get_distance(distance, type, 1);
     1476                d=get_distance(nav, distance, type, 1);
    14451477                ret=g_strdup_printf(_("Follow the road for the next %s"), d);
    14461478                g_free(d);
    14471479                return ret;
     
    14491481                d=g_strdup(_("soon"));
    14501482                break;
    14511483        case 1:
    1452                 d=get_distance(distance, type, 0);
     1484                d=get_distance(nav, distance, type, 0);
    14531485                break;
    14541486        case 0:
    14551487                skip_roads = count_possible_turns(nav->first,cmd->itm,cmd->delta);
  • navit/navit/navigation.h

     
    2020#ifndef NAVIT_NAVIGATION_H
    2121#define NAVIT_NAVIGATION_H
    2222
     23#define FEET_PER_METER 3.2808399;
     24#define FEET_PER_MILE  5280
     25
    2326#ifdef __cplusplus
    2427extern "C" {
    2528#endif
  • navit/navit/navit.c

     
    138138        struct vehicleprofile *vehicleprofile;
    139139        GList *vehicleprofiles;
    140140        int pitch;
     141        int imperial;
    141142};
    142143
    143144struct gui *main_loop_gui;
     
    16001601                if (!init && attr_updated && this_->ready == 3)
    16011602                        navit_draw(this_);
    16021603                break;
     1604        case attr_imperial:
     1605                attr_updated=(this_->imperial != attr->u.num);
     1606                this_->imperial=attr->u.num;
     1607                break;
    16031608        case attr_projection:
    16041609                if(this_->trans && transform_get_projection(this_->trans) != attr->u.projection) {
    16051610                        navit_projection_set(this_, attr->u.projection);
     
    17351740                attr->u.gui=this_->gui;
    17361741                ret=(attr->u.gui != NULL);
    17371742                break;
     1743        case attr_imperial:
     1744                attr->u.num=this_->imperial;
     1745                break;
    17381746        case attr_layout:
    17391747                if (iter) {
    17401748                        if (iter->u.list) {