void roadmap_ticker_initialize(void){
RoadMapImage image;
gInitialized = FALSE;
if ( roadmap_screen_is_hd_screen() )
{
gTickerTopBarOffset = -5;
}
roadmap_config_declare_enumeration ("user", &ShowTickerCfg, NULL, "yes", "no", NULL);
image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, TICKER_MIDDLE_IMAGE);
if ( image == NULL){
roadmap_log (ROADMAP_ERROR, "roadmap_ticker - cannot load %s image ", TICKER_MIDDLE_IMAGE);
return;
}
gMiddleImageSize.width = roadmap_canvas_image_width( image );
gMiddleImageSize.height = roadmap_canvas_image_height( image );
OpenIconRct.miny = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset();
OpenIconRct.maxy = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + gMiddleImageSize.height;
RoadMapTickerPen = roadmap_canvas_create_pen ("Ticker_pen");
roadmap_canvas_set_foreground (TICKER_FOREGROUND);
show_close_icon();
roadmap_pointer_register_pressed
(roadmap_ticker_key_pressed, POINTER_HIGH);
roadmap_pointer_register_short_click(roadmap_ticker_short_click, POINTER_HIGH);
gInitialized = TRUE;
}
void roadmap_canvas3_ogl_updateScale(int zoom) {
float angRad;
//static float maxAngle= 67.3;
static float maxAngle= 62;
float ang= 24;
//float angZoom= 384;
float angZoom= 3000;
if (!isInitialized || zoom== 0)
return;
if ( !is_canvas_ready() )
return;
if ( roadmap_screen_is_hd_screen() ) {
zoom /= 2;
}
while (angZoom > zoom) {
angZoom/= 1.1;
ang= ang* 1.026; // (5/4)^(ln(1.1)/ln(2))
}
if (ang > maxAngle)
ang= maxAngle;
angRad= ang*M_PI/180;
if (angRad!= angle) {
double distH;
angle= angRad;
distH= roadmap_canvas_ogl_rotateMe(0);
roadmap_log(ROADMAP_DEBUG,"zoom= %d angle= %lf y dist= %lg\n",zoom,ang,distH);
}
}
static NOPH_Font_t roadmap_canvas_getFont(int size) {
static NOPH_Font_t s_fontDefault;
static int deviceVersion = 0;
if(!deviceVersion)
deviceVersion = NOPH_FreemapApp_getDeviceVersion();
if(size<=0) // the default font is too small, so set it manually.
size = 12;
if(roadmap_screen_is_hd_screen()) {
size = size * 1.6;
if ( deviceVersion == 8900)
size +=2; // 8900 has a bigger resolution, so use a bigger font.
if (deviceVersion == 9100)
size -=2;
}
if(!s_fontDefault)
s_fontDefault = NOPH_Font_getDefault();
if (size>MAX_FONT_SIZE)
size = MAX_FONT_SIZE;
if(static_fonts[size] == 0)
static_fonts[size] = NOPH_Font_derive(s_fontDefault, NOPH_Font_BOLD, size);
return static_fonts[size];
}
static SsdWidget space (int height) {
SsdWidget space;
if (roadmap_screen_is_hd_screen())
height *= 2;
space = ssd_container_new ("spacer", NULL, SSD_MAX_SIZE, height, SSD_WIDGET_SPACE | SSD_END_ROW);
ssd_widget_set_color (space, NULL, NULL);
return space;
}
void roadmap_groups_dialog (RoadMapCallback callback) {
int row_height = 60;
SsdWidget groupDlg;
SsdWidget list;
int flags = 0;
int i;
int count;
const char *active_name;
static char *labels[MAX_GROUPS] ;
static void *values[MAX_GROUPS] ;
static void *icons[MAX_GROUPS];
int num_following;
if (roadmap_screen_is_hd_screen()){
row_height = 80;
}
#ifdef OPENGL
flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif
groupDlg = ssd_dialog_new ( "groupDlg", roadmap_lang_get ("Groups"), NULL, SSD_CONTAINER_TITLE);
groupDlg->context = (void *)callback;
list = ssd_list_new ("list", SSD_MAX_SIZE, SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_list_resize ( list, row_height );
active_name = roadmap_groups_get_active_group_name();
count = roadmap_groups_get_num_following();
num_following = roadmap_groups_get_num_following();
if (active_name[0] != 0){
values[0] = (void *)roadmap_groups_get_active_group_name();
icons[0] = (void *) roadmap_groups_get_active_group_icon();
labels[0] = (char *)active_name;
num_following -= 1;
}
else{
values[0] = "";
icons[0] = NULL;
labels[0] = (char *)roadmap_lang_get("No group");
}
for (i = 0; i< num_following; i++){
values[i+1] = (void *)roadmap_group_get_following_name(i);
icons[i+1] = (void *) roadmap_group_get_following_icon(i);
labels[i+1] = (char *) roadmap_group_get_following_name(i);
}
if (active_name[0] != 0){
values[count] = "";
icons[count] = NULL;
labels[count] = (char *)roadmap_lang_get("No group");
}
ssd_list_populate (list, count+1, (const char **)labels, (const void **)values, (const char **)icons, NULL, groups_callback, NULL, FALSE);
ssd_widget_add (groupDlg, list);
ssd_dialog_activate ("groupDlg", NULL);
ssd_dialog_draw ();
}
static inline int is_click( const RoadMapGuiPoint *point ){
const int threshold = roadmap_screen_is_hd_screen() ?
((3 * CLICK_MOVEMENT_THR)/2) : CLICK_MOVEMENT_THR;
if ( ( abs( first_pointer_point.x - point->x ) <= threshold ) &&
( abs( first_pointer_point.y - point->y ) <= threshold ) )
{
return 1;
}
return 0;
}
static void roadmap_speedometer_after_refresh (void){
RoadMapGuiPoint image_position;
RoadMapGuiPoint text_position;
RoadMapGuiPoint units_position;
RoadMapGpsPosition pos;
RoadMapPen speedometer_pen;
char str[30];
char unit_str[30];
int font_size = 20;
int font_size_units = 10;
int speed_offset = 6;
int units_offset = 6;
int speed;
#ifdef IPHONE_NATIVE
font_size = 18;
font_size_units = 8;
#else
if ( roadmap_lang_rtl() )
font_size_units--; // Longer text for units
#endif
if (SpeedometerImage == NULL){
return;
}
if (gHideSpeedometer){
after_refresh_callback();
return;
}
if (!roadmap_map_settings_isShowSpeedometer()){
after_refresh_callback();
return;
}
if (roadmap_screen_is_hd_screen()){
speed_offset *= 1.5;
units_offset *= 1.5;
}
roadmap_navigate_get_current (&pos, NULL, NULL);
speed = pos.speed;
if ((speed == -1) || !roadmap_gps_have_reception()){
after_refresh_callback();
return;
}
speedometer_pen = roadmap_canvas_create_pen ("speedometer_pen");
if (roadmap_skin_state() == 1)
roadmap_canvas_set_foreground(SPEEDOMETER_SPEED_COLOR_NIGHT);
else
roadmap_canvas_set_foreground(SPEEDOMETER_SPEED_COLOR_DAY);
image_position.x = roadmap_canvas_width() - roadmap_canvas_image_width(SpeedometerImage);
image_position.y = roadmap_canvas_height() - roadmap_canvas_image_height(SpeedometerImage) - roadmap_bar_bottom_height() - gOffset;
roadmap_canvas_draw_image (SpeedometerImage, &image_position, 0, IMAGE_NORMAL);
text_position.y = image_position.y + roadmap_canvas_image_height(SpeedometerImage) *.8;
units_position.y = image_position.y + roadmap_canvas_image_height(SpeedometerImage)*.8;
if (speed != -1){
if (!roadmap_gps_is_show_raw()) {
snprintf (str, sizeof(str), "%3d", roadmap_math_to_speed_unit(speed));
snprintf (unit_str, sizeof(unit_str), "%s", roadmap_lang_get(roadmap_math_speed_unit()));
} else {
snprintf (str, sizeof(str), "%3d", pos.accuracy);
snprintf (unit_str, sizeof(unit_str), "%s", "ac");
}
if (ssd_widget_rtl(NULL)){
text_position.x = roadmap_canvas_width() -speed_offset;
roadmap_canvas_draw_string_size(&text_position, ROADMAP_CANVAS_BOTTOMRIGHT, font_size, str);
units_position.x = image_position.x + units_offset;
roadmap_canvas_draw_string_size(&units_position, ROADMAP_CANVAS_BOTTOMLEFT, font_size_units, unit_str);
}
else{
text_position.x = image_position.x + speed_offset;
roadmap_canvas_draw_string_size(&text_position, ROADMAP_CANVAS_BOTTOMLEFT, font_size, str);
units_position.x = roadmap_canvas_width() -units_offset;
roadmap_canvas_draw_string_size(&units_position, ROADMAP_CANVAS_BOTTOMRIGHT, font_size_units, unit_str);
}
}
after_refresh_callback();
}
void roadmap_ticker_display() {
char text[256];
char points[20];
char rank[20];
int text_width, ascent, descent;
RoadMapGuiPoint position;
RoadMapGuiPoint text_position;
RoadMapImage image;
int start,end, start_x;
int iMyTotalPoints;
int iMyRanking;
int allign;
int width;
int text_offset_y = 25;
int point_start_x = 190;
int rank_start_x = 270;
int new_pnts_start_x = 50;
RoadMapImage x_image = NULL;
const char * point_text = NULL;
if ( roadmap_screen_is_hd_screen() )
{
text_offset_y = 22;
point_start_x = 200;
rank_start_x = 280;
new_pnts_start_x = 65;
}
width = roadmap_canvas_width();
if (!gInitialized) return ;
if (!ticker_cfg_on() && !gTickerSupressHide){
gTickerOn = FALSE;
return;
}
if (gTickerHide ){
gTickerOn = FALSE;
return;
}
if (!roadmap_message_format (text, sizeof(text), "%X|%*")) {
if (gTickerSupressHide){
roadmap_message_set('*', "%d", 0);
roadmap_message_format (text, sizeof(text), "%*");
}
else{
show_close_icon();
gTickerOn = FALSE;
return;
}
}
gTickerOn = TRUE;
roadmap_canvas_get_text_extents (text, 14, &text_width, &ascent, &descent, NULL);
roadmap_canvas_select_pen (RoadMapTickerPen);
end = roadmap_canvas_width();
start = 1;
start_x = 1;
image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, TICKER_MIDDLE_IMAGE);
if ( image )
{
while (start < end){
position.x = start;
position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset();
roadmap_canvas_draw_image ( image, &position, 0, IMAGE_NORMAL);
start += roadmap_canvas_image_width( image );
}
}
position.x = 0;
if (ssd_widget_rtl(NULL)){
allign = ROADMAP_CANVAS_RIGHT;
text_position.x = roadmap_canvas_width() -4;
}
else{
allign = ROADMAP_CANVAS_LEFT;
text_position.x = 4;
}
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + 2;
roadmap_canvas_draw_string_size (&text_position,
allign |ROADMAP_CANVAS_TOP,
14,roadmap_lang_get("Your Points (updated daily)"));
text_position.x = 4;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + 2 +TICKER_TOP_BAR_TEXT_OFFSET;
switch( gLastUpdateEvent ) {
case default_event:
point_text = roadmap_lang_get("New points");
break;
case report_event:
point_text = roadmap_lang_get("Road report");
break;
case comment_event:
point_text = roadmap_lang_get("Event comment");
break;
case confirm_event:
point_text= roadmap_lang_get("Prompt response");
break;
case road_munching_event :
point_text= roadmap_lang_get("Road munching");
break;
case user_contribution_event :
point_text= roadmap_lang_get("Traffic detection");
break;
case bonus_points :
point_text= roadmap_lang_get("Bonus points");
break;
}
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,point_text);
image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, TICKER_DIVIDER);
if ( image )
{
position.y = roadmap_bar_top_height() + TICKER_TOP_BAR_DIVIDER_OFFSET;
position.x = width /3 +4 + 30;
roadmap_canvas_draw_image ( image, &position, 0, IMAGE_NORMAL);
position.y = roadmap_bar_top_height() + TICKER_TOP_BAR_DIVIDER_OFFSET;
position.x = 2*width/3+4 +15;
roadmap_canvas_draw_image ( image, &position, 0, IMAGE_NORMAL);
}
text_position.x = (width/3) + (width/3)/4 + 30;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + 2 + TICKER_TOP_BAR_TEXT_OFFSET;
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,roadmap_lang_get("Total"));
text_position.x = (width/3) + (width/3)/4+ 30;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + text_offset_y +TICKER_TOP_BAR_TEXT_OFFSET;
iMyTotalPoints = editor_points_get_total_points();
if (iMyTotalPoints != -1){
if (iMyTotalPoints < 10000){
sprintf(points,"%d", iMyTotalPoints);
}
else{
sprintf(points,"%dK", (int)iMyTotalPoints/1000);
}
}
else{
strcpy(points,"");
}
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,points);
text_position.x = width - (width/3) + (width/3)/4+ 15;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + 2 +TICKER_TOP_BAR_TEXT_OFFSET;
iMyRanking = RealTime_GetMyRanking();
if (iMyRanking == -1)
strcpy(rank,"");
else
sprintf(rank, "%d", iMyRanking);
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,roadmap_lang_get("Rank"));
text_position.x = width - (width/3) + (width/3)/4+ 12;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + text_offset_y +TICKER_TOP_BAR_TEXT_OFFSET;
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,rank);
if (strcmp(text,"0")){
text_position.x = new_pnts_start_x - start_x + 30;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + text_offset_y +TICKER_TOP_BAR_TEXT_OFFSET;
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,"+");
text_position.x = new_pnts_start_x - start_x + 40;
text_position.y = roadmap_bar_top_height() + roadmap_ticker_top_bar_offset() + text_offset_y +TICKER_TOP_BAR_TEXT_OFFSET;
roadmap_canvas_draw_string_size (&text_position,
ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP,
14,text);
}
#ifdef TOUCH_SCREEN
x_image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, "x_close");
if ( x_image ) {
position.x = roadmap_canvas_width() - roadmap_canvas_image_width(x_image) - 5;
position.y = roadmap_bar_top_height() + gMiddleImageSize.height -roadmap_canvas_image_height(x_image) -5;
roadmap_canvas_draw_image ( x_image, &position, 0, IMAGE_NORMAL);
}
#endif
}
SsdWidget navigate_res_ETA_widget(int iRouteDistance, int iRouteLenght, const char *via, BOOL showDistance, BOOL showAltBtn, SsdCallback callback){
SsdWidget ETA_container, inner_container, button, text;
char *icon[3];
int inner_width;
int font_size;
int alt_route_button_w = 60;
int width = SSD_MAX_SIZE;
int factor = 10;
int num_spaces = 7;
if (roadmap_screen_is_hd_screen())
alt_route_button_w = 90;
#ifdef IPHONE_NATIVE
width = 280;
#else
width = roadmap_canvas_width() - 40;
if (roadmap_canvas_height() < roadmap_canvas_width())
width = roadmap_canvas_height() - 40;
#endif
#ifndef TOUCH_SCREEN
alt_route_button_w = 0;
#endif
ETA_container = ssd_container_new ("eta container", NULL, width, SSD_MIN_SIZE,
SSD_WIDGET_SPACE | SSD_ALIGN_CENTER | SSD_END_ROW );
ssd_widget_set_color(ETA_container, NULL, NULL);
if (roadmap_canvas_width() > roadmap_canvas_height()){
inner_width = roadmap_canvas_height() - alt_route_button_w - 40;
}else{
inner_width = roadmap_canvas_width() - alt_route_button_w - 40;
}
inner_container = ssd_container_new ("inner container", NULL, inner_width, SSD_MIN_SIZE,
SSD_WIDGET_SPACE | SSD_END_ROW );
ssd_widget_set_color(inner_container, NULL, NULL);
// Add Alternatives buttons
#ifdef TOUCH_SCREEN
if (roadmap_alternative_feature_enabled() && RealTimeLoginState () && showAltBtn){
icon[0] = "alternative_button";
icon[1] = "alternative_button_s";
icon[2] = NULL;
button = ssd_button_new("Alt_button", "Alt",(const char**) &icon[0], 2, SSD_ALIGN_RIGHT|SSD_WS_TABSTOP, callback);
ssd_widget_add(ETA_container, button);
}
#endif
#ifdef IPHONE_NATIVE
// ssd_widget_add (inner_container, space (7));
#endif
font_size = 30;
#ifdef RIMAPI
font_size = 22;
#endif
text = ssd_text_new ("ETA_W_Minutes_Text", "", font_size, 0);
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
ssd_dialog_add_hspace(inner_container, 3, 0);
font_size = 24;
#ifdef RIMAPI
ssd_widget_set_offset(text, 0, 4);
font_size = 16;
#endif
text = ssd_text_new ("ETA__W_Min_text", roadmap_lang_get ("min."), font_size, 0);
ssd_text_set_color(text,"#ffffff");
#ifndef RIMAPI
ssd_widget_set_offset(text, 0, 6);
#else
ssd_widget_set_offset(text, 0, 13);
#endif
ssd_widget_add (inner_container, text);
if (showDistance){
#ifndef RIMAPI
ssd_dialog_add_hspace(inner_container, 5, 0);
#else
ssd_dialog_add_hspace(inner_container, 3, 0);
#endif
text = ssd_text_new ("ETA_W_Distance_Text", "", 18, SSD_TEXT_NORMAL_FONT);
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
//#ifndef IPHONE_NATIVE
#ifdef RIMAPI
ssd_dialog_add_hspace(inner_container, 1, 0);
ssd_widget_set_offset(text, 0, 11);
#else
ssd_dialog_add_hspace(inner_container, 3, 0);
ssd_widget_set_offset(text, 0, 14);
#endif
//#endif
text = ssd_text_new ("ETA_W_Distance_Unit_Text", "", 16, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
//#ifndef IPHONE_NATIVE
#ifdef RIMAPI
ssd_widget_set_offset(text, 0, 13);
#else
ssd_widget_set_offset(text, 0, 15);
#endif
//#endif
}
#ifdef RIMAPI
num_spaces = 2;
#endif
ssd_widget_add (inner_container, space (num_spaces));
text = ssd_text_new ("ETA_Text", "", 18, SSD_TEXT_NORMAL_FONT);
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
ssd_dialog_add_hspace(inner_container, 3, 0);
text = ssd_text_new ("ETA_W_ETA_TIME_Text", "", 18, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
ssd_widget_add (inner_container, space (2));
// VIA Text
#ifndef RIMAPI
text = ssd_text_new ("ETA_W_VIA_Text", "", 16, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
#else
text = ssd_text_new ("ETA_W_VIA_Text", "", 13, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
#endif
ssd_text_set_color(text,"#ffffff");
ssd_widget_add (inner_container, text);
ssd_widget_add(ETA_container, inner_container);
navigate_res_update_ETA_widget(ETA_container, iRouteDistance, iRouteLenght, via, showDistance);
return ETA_container;
}
static char* get_download_url (int type, const char *lang, const char* name) {
char* url;
const char* url_prefix;
const char* url_ver;
switch (type) {
case RES_DOWNLOAD_IMAGE:
url_prefix = get_images_url_prefix ();
url_ver = get_images_url_ver();
break;
case RES_DOWNLOAD_COUNTRY_SPECIFIC_IMAGES:
url_prefix = get_country_specific_images_url_prefix();
url_ver = get_country_specific_images_url_ver();
break;
case RES_DOWNLOAD_SOUND:
url_prefix = get_sound_url_prefix ();
url_ver = get_sound_url_ver();
break;
case RES_DOWNLOAD_LANG:
url_prefix = get_langs_url_prefix ();
url_ver = get_langs_url_ver();
break;
default:
url_prefix = get_config_url_prefix ();
url_ver = get_config_url_ver();
break;
}
if (!*url_prefix){
roadmap_log (ROADMAP_ERROR,"Failed to download resource. URL prefix is empty type=%d, lang=%s, name=%s" ,type, lang, name );
return NULL;
}
// Size of prefix + size of image id + '\0'
url = malloc (strlen (url_prefix) + strlen(url_ver) + strlen (name) + +strlen (lang) + +strlen (
roadmap_geo_config_get_server_id ()) + 10);
roadmap_check_allocated( url );
strcpy (url, url_prefix);
if (url_ver[0] != 0){
strcat (url, url_ver);
strcat (url, "/");
}
if (lang && (lang[0] != 0)) {
strcat (url, lang);
strcat (url, "/");
}
if (type == RES_DOWNLOAD_CONFIFG) {
strcat (url, roadmap_geo_config_get_server_id ());
strcat (url, "/");
}
if (roadmap_screen_is_hd_screen()){
if (( type == RES_DOWNLOAD_IMAGE ) || ( type == RES_DOWNLOAD_COUNTRY_SPECIFIC_IMAGES )){
strcat (url, "HD");
strcat (url, "/");
}
}
else
{
#ifndef TOUCH_SCREEN
if (( type == RES_DOWNLOAD_IMAGE ) || ( type == RES_DOWNLOAD_COUNTRY_SPECIFIC_IMAGES )){
strcat (url, "no_touch");
strcat (url, "/");
}
#endif
}
strcat (url, name);
return url;
}
void roadmap_canvas_draw_formated_string_angle (const RoadMapGuiPoint *position,
RoadMapGuiPoint *center,
int angle, int size,
int font_type,
const char *text)
{
font_manager_type *fman;
font_manager_type *image_fman;
font_engine_type *feng;
font_engine_type *image_feng;
if ((font_type & FONT_TYPE_NORMAL) && (!RoadMapCanvasNormalFontLoaded))
font_type = FONT_TYPE_BOLD;
if (font_type & FONT_TYPE_NORMAL){
fman = &m_fman_nor;
feng = &m_feng_nor;
image_feng = &m_image_feng_nor;
image_fman = &m_image_fman_nor;
}
else{
fman = &m_fman;
feng = &m_feng;
image_feng = &m_image_feng;
image_fman = &m_image_fman;
}
if ((font_type & FONT_TYPE_BOLD) && (RoadMapCanvasFontLoaded != 1)) return;
dbg_time_start(DBG_TIME_TEXT_FULL);
dbg_time_start(DBG_TIME_TEXT_CNV);
wchar_t wstr[255];
int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);
if (length <=0) return;
#ifdef USE_FRIBIDI
wchar_t *bidi_text = bidi_string(wstr);
const wchar_t* p = bidi_text;
#else
const wchar_t* p = wstr;
#endif
ren_solid.color(CurrentPen->color);
dbg_time_end(DBG_TIME_TEXT_CNV);
double x = 0;
double y = 0;
if (size < 0) size = 15;
if ( roadmap_screen_is_hd_screen() )
{
size = (int)(size * CANVAS_HD_FONT_FACTOR);
}
else{
#ifdef _WIN32
size = (int) (size * 0.9);
#endif
}
if (angle == 0) {
/* Use faster drawing for text with no angle */
x = position->x;
y = position->y;
// ren_solid.color(agg::rgba8(0, 0, 0));
image_feng->height(size);
image_feng->width(size);
while(*p) {
const agg::glyph_cache* glyph = image_fman->glyph(*p);
if(glyph) {
image_fman->init_embedded_adaptors(glyph, x, y);
agg::render_scanlines(image_fman->gray8_adaptor(),
image_fman->gray8_scanline(),
ren_solid);
// increment pen position
x += glyph->advance_x;
y += glyph->advance_y;
}
++p;
}
}
else{
feng->height(size);
feng->width(size);
}
while(*p) {
dbg_time_start(DBG_TIME_TEXT_ONE_LETTER);
dbg_time_start(DBG_TIME_TEXT_GET_GLYPH);
const agg::glyph_cache* glyph = fman->glyph(*p);
dbg_time_end(DBG_TIME_TEXT_GET_GLYPH);
if(glyph) {
fman->init_embedded_adaptors(glyph, x, y);
//agg::conv_curve<font_manager_type::path_adaptor_type> stroke(fman->path_adaptor());
agg::trans_affine mtx;
if (abs(angle) > 0) {
mtx *= agg::trans_affine_rotation(agg::deg2rad(angle));
}
mtx *= agg::trans_affine_translation(position->x, position->y);
agg::conv_transform<font_manager_type::path_adaptor_type> tr(fman->path_adaptor(), mtx);
agg::conv_curve<agg::conv_transform<font_manager_type::path_adaptor_type> > fill(tr);
//agg::conv_stroke<
//agg::conv_curve<agg::conv_transform<font_manager_type::path_adaptor_type> > >
//stroke(fill);
//agg::conv_contour<agg::conv_transform<font_manager_type::path_adaptor_type> >contour(tr);
//contour.width(2);
//agg::conv_stroke< agg::conv_contour<agg::conv_transform<font_manager_type::path_adaptor_type> > > stroke(contour);
//agg::conv_stroke< agg::conv_transform<font_manager_type::path_adaptor_type> > stroke(tr);
dbg_time_start(DBG_TIME_TEXT_ONE_RAS);
#ifdef WIN32_PROFILE
ResumeCAPAll();
#endif
ras.reset();
ras.add_path(tr);
agg::render_scanlines(ras, sl, ren_solid);
//ras.add_path(fill);
//ras.add_path(stroke);
//ren_solid.color(agg::rgba8(255, 255, 255));
//agg::render_scanlines(ras, sl, ren_solid);
//ras.add_path(tr);
//ren_solid.color(agg::rgba8(0, 0, 0));
//agg::render_scanlines(ras, sl, ren_solid);
#ifdef WIN32_PROFILE
SuspendCAPAll();
#endif
dbg_time_end(DBG_TIME_TEXT_ONE_RAS);
// increment pen position
x += glyph->advance_x;
y += glyph->advance_y;
dbg_time_end(DBG_TIME_TEXT_ONE_LETTER);
}
++p;
}
#ifdef USE_FRIBIDI
free(bidi_text);
#endif
dbg_time_end(DBG_TIME_TEXT_FULL);
}
void roadmap_canvas_get_formated_text_extents
(const char *text, int size, int *width,
int *ascent, int *descent, int *can_tilt, int font_type){
*ascent = 0;
*descent = 0;
font_manager_type *fman;
font_engine_type *feng;
font_engine_type *image_feng;
wchar_t wstr[255];
if (can_tilt) *can_tilt = 1;
if ((font_type & FONT_TYPE_NORMAL) && (!RoadMapCanvasNormalFontLoaded))
font_type = FONT_TYPE_BOLD;
int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);
if (length <=0) {
*width = 0;
return;
}
double x = 0;
double y = 0;
const wchar_t* p = wstr;
if (font_type & FONT_TYPE_NORMAL){
feng = &m_feng_nor;
image_feng = &m_image_feng_nor;
}
else{
feng = &m_feng;
image_feng = &m_image_feng;
}
if (size == -1) {
size = 15;
if ( roadmap_screen_is_hd_screen() )
{
size = (int)(size * CANVAS_HD_FONT_FACTOR);
}
else{
#ifdef _WIN32
size = (int) (size * 0.9);
#endif
}
feng->height(size);
feng->width(size);
/* Use the regular font */
*descent = abs((int)feng->descender()) + 1;
*ascent = (int)feng->ascender() + 1;
if (font_type & FONT_TYPE_NORMAL)
fman = &m_fman_nor;
else
fman = &m_fman;
} else {
if ( roadmap_screen_is_hd_screen() )
{
size = (int) (size * CANVAS_HD_FONT_FACTOR);
}
else{
#ifdef _WIN32
size = (int) (size * 0.9);
#endif
}
image_feng->height(size);
image_feng->width(size);
*descent = abs((int)image_feng->descender()) + 1;
*ascent = (int)image_feng->ascender() + 1;
if (font_type & FONT_TYPE_NORMAL)
fman = &m_image_fman_nor;
else
fman = &m_image_fman;
}
while(*p) {
const agg::glyph_cache* glyph = fman->glyph(*p);
if(glyph) {
x += glyph->advance_x;
y += glyph->advance_y;
//if (-glyph->bounds.y1 > *descent) *descent=-glyph->bounds.y1 - 1;
}
++p;
}
*width = (int)x;
}
void roadmap_canvas_draw_image_formated_text (RoadMapImage image,
const RoadMapGuiPoint *position,
int size, const char *text, int font_type) {
font_manager_type *image_fman;
font_engine_type *image_feng;
if (RoadMapCanvasFontLoaded != 1) return;
if ((font_type & FONT_TYPE_NORMAL) && (!RoadMapCanvasNormalFontLoaded))
font_type = FONT_TYPE_BOLD;
if (font_type & FONT_TYPE_NORMAL){
image_fman = &m_image_fman_nor;
image_feng = &m_image_feng_nor;
}
else{
image_fman = &m_image_fman;
image_feng = &m_image_feng;
}
wchar_t wstr[255];
int length = roadmap_canvas_agg_to_wchar (text, wstr, 255);
if (length <=0) return;
#ifdef USE_FRIBIDI
wchar_t *bidi_text = bidi_string(wstr);
const wchar_t* p = bidi_text;
#else
const wchar_t* p = wstr;
#endif
if ( !roadmap_canvas_check_cached( image ) )
{
return;
}
if ( roadmap_screen_is_hd_screen() )
{
size = (int) (size * CANVAS_HD_FONT_FACTOR);
}
else{
#ifdef _WIN32
size = (int) (size * 0.9);
#endif
}
double x = position->x;
double y = position->y + size - 7;
if ( roadmap_screen_is_hd_screen() )
{
y -= 3;
}
agg::renderer_base<agg::pixfmt_rgba32> renb(image->pixfmt);
agg::renderer_scanline_aa_solid< agg::renderer_base<agg::pixfmt_rgba32> > ren_solid (renb);
//ren_solid.color(agg::rgba8(255, 255, 255));
ren_solid.color(CurrentPen->color);
image_feng->height(size);
image_feng->width(size);
while(*p) {
const agg::glyph_cache* glyph = image_fman->glyph(*p);
if(glyph) {
image_fman->init_embedded_adaptors(glyph, x, y);
agg::render_scanlines(image_fman->gray8_adaptor(),
image_fman->gray8_scanline(),
ren_solid);
// increment pen position
x += glyph->advance_x;
y += glyph->advance_y;
}
++p;
}
#ifdef USE_FRIBIDI
free(bidi_text);
#endif
}
static void roadmap_display_console_box
(int type, int corner, const char *format) {
char text[256];
int count;
int width, ascent, descent;
int warning_font_size = 13;
int offset = 62;
#ifdef ANDROID
warning_font_size = 15;
#endif
RoadMapGuiPoint frame[4];
#ifdef _WIN32
offset = 33;
#endif
count = 4;
if (! roadmap_message_format (text, sizeof(text), format)) {
return;
}
#ifdef QTMOBILITY
{
roadmap_display_set_message(text);
return;
}
#endif
if ( type == ROADMAP_CONSOLE_WARNING ){
roadmap_canvas_get_text_extents (text, warning_font_size, &width, &ascent, &descent, NULL);
while (width > (roadmap_canvas_width()-10)){
warning_font_size--;
roadmap_canvas_get_text_extents (text, warning_font_size, &width, &ascent, &descent, NULL);
}
}
else if (type == ROADMAP_CONSOLE_ACTIVITY ){
roadmap_canvas_get_text_extents (text, 12, &width, &ascent, &descent, NULL);
}
else
{
roadmap_canvas_get_text_extents (text, 16, &width, &ascent, &descent, NULL);
}
if (roadmap_screen_is_hd_screen())
offset = 94;
if (type == ROADMAP_CONSOLE_ACTIVITY) {
#ifdef TOUCH_SCREEN
if (roadmap_horizontal_screen_orientation())
frame[2].x = roadmap_canvas_width() - offset;
else
#endif
frame[2].x = roadmap_canvas_width() ;
frame[0].x = frame[2].x - width - 4;
} else if (corner & ROADMAP_CANVAS_RIGHT) {
#ifdef TOUCH_SCREEN
if (roadmap_horizontal_screen_orientation())
frame[2].x = roadmap_canvas_width() - 5-offset;
else
#endif
frame[2].x = roadmap_canvas_width() - 1 ;
frame[0].x = frame[2].x - width - 6;
} else {
frame[0].x = 5;
frame[2].x = frame[0].x + width + 6;
}
frame[1].x = frame[0].x;
frame[3].x = frame[2].x;
if (corner & ROADMAP_CANVAS_BOTTOM) {
frame[0].y = roadmap_canvas_height () - ascent - descent - 11 - 22;
frame[1].y = roadmap_canvas_height () - 6 - 22;
} else {
if ( type == ROADMAP_CONSOLE_ACTIVITY || type == ROADMAP_CONSOLE_WARNING )
{
frame[0].y = roadmap_bar_top_height() + roadmap_ticker_height()+ roadmap_message_ticker_height()+1;
}
else
{
frame[0].y = 40;
}
frame[1].y = ascent + descent + frame[0].y + 6;
}
frame[2].y = frame[1].y;
frame[3].y = frame[0].y;
count = 4;
if (type == ROADMAP_CONSOLE_WARNING ) {
roadmap_canvas_select_pen (RoadMapWarningBackground);
roadmap_canvas_set_opacity(181);
}
else if (type == ROADMAP_CONSOLE_ACTIVITY) {
roadmap_canvas_select_pen (RoadMapActivityBackground);
} else {
roadmap_canvas_select_pen (RoadMapConsoleBackground);
}
roadmap_canvas_draw_multiple_polygons (1, &count, frame, 1, 0);
if (type == ROADMAP_CONSOLE_WARNING) {
roadmap_canvas_select_pen (RoadMapWarningForeground);
}
else if (type == ROADMAP_CONSOLE_ACTIVITY) {
roadmap_canvas_select_pen (RoadMapActivityForeground);
} else {
roadmap_canvas_select_pen (RoadMapConsoleForeground);
}
if (type != ROADMAP_CONSOLE_WARNING )
roadmap_canvas_draw_multiple_polygons (1, &count, frame, 0, 0);
frame[0].x = frame[3].x - 3;
frame[0].y = frame[3].y + 1;
if (type == ROADMAP_CONSOLE_WARNING )
{
roadmap_canvas_draw_string_size (frame,
ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP,
warning_font_size,text);
}
else if (type == ROADMAP_CONSOLE_ACTIVITY)
roadmap_canvas_draw_string_size (frame,
ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP,
12,text);
else
roadmap_canvas_draw_string (frame,
ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP,
text);
}
static int get_drag_movement_thr(void){
if ( roadmap_screen_is_hd_screen() )
return DRAG_MOVEMENT_THR * 2;
return DRAG_MOVEMENT_THR;
}
static void add_title (SsdWidget w, int flags) {
SsdWidget title, text;
int rt_soft_key_flag;
int lf_soft_key_flag;
int align_flag = SSD_ALIGN_CENTER;
#ifdef TOUCH_SCREEN
const char *back_buttons[] = {"back_button", "back_button_s"};
#endif
if (ssd_widget_rtl (NULL)) {
rt_soft_key_flag = SSD_END_ROW;
lf_soft_key_flag = SSD_ALIGN_RIGHT;
}
else{
rt_soft_key_flag = SSD_ALIGN_RIGHT;
lf_soft_key_flag = SSD_END_ROW;
}
if (!((w->flags & SSD_DIALOG_FLOAT) && !(w->flags & SSD_DIALOG_TRANSPARENT)))
{
int height = ADJ_SCALE( 34 );
#ifdef ANDROID
align_flag = 0;
#endif //ANDROID
#ifndef TOUCH_SCREEN
height = 28;
#endif
title = ssd_container_new ("title_bar", NULL, SSD_MAX_SIZE, height, SSD_END_ROW);
ssd_widget_set_click_offsets_ext( title, 0, 0, 0, 10 );
ssd_widget_set_offset(title, 0, 0);
title->draw = draw_title;
}
else{
int height = 28;
if ( roadmap_screen_is_hd_screen() )
{
height = height*1.8;
}
title = ssd_container_new ("title_bar", NULL, SSD_MAX_SIZE, height,
SSD_END_ROW);
}
ssd_widget_set_color (title, "#ffffff", "#ff0000000");
text = ssd_text_new ("title_text", "" , 13, SSD_WIDGET_SPACE|SSD_ALIGN_VCENTER|align_flag);
ssd_widget_set_color (text, "#ffffff", "#ff0000000");
if ((w->flags & SSD_ROUNDED_CORNERS) && (!(w->flags & SSD_POINTER_MENU)))
ssd_widget_set_color (text, "#ffffff", "#ff0000000");
if (w->flags & SSD_CONTAINER_TITLE){
if (w->flags & SSD_ROUNDED_BLACK)
ssd_widget_set_color (text, "#ffffff", "#ffffff");
else if (!(w->flags & SSD_DIALOG_FLOAT))
ssd_widget_set_color (text, "#ffffff", "#ff0000000");
else
if (flags & SSD_DIALOG_TRANSPARENT)
ssd_widget_set_color (text, "#ffffff", "#ff0000000");
else
ssd_widget_set_color (text, "#000000", "#ff0000000");
}
#if defined(TOUCH_SCREEN)
if (!( ((flags & SSD_DIALOG_FLOAT)&& !(flags & SSD_DIALOG_TRANSPARENT)) || (flags & SSD_DIALOG_NO_BACK))){
SsdWidget btn = NULL;
#ifndef ANDROID
btn = ssd_button_new (SSD_DIALOG_BUTTON_BACK_NAME, "", back_buttons, 2,
SSD_ALIGN_VCENTER, button_callback );
#endif
if ( ssd_widget_rtl(NULL) )
{
SsdWidget btn2 = ssd_button_new ("right_title_button", "", back_buttons, 2,
SSD_ALIGN_VCENTER, NULL );
ssd_widget_add( title, btn2 );
ssd_widget_set_click_offsets_ext( btn2, -40, -20, 20, 10 );
ssd_widget_hide(btn2);
#ifdef ANDROID
ssd_dialog_add_hspace (title, 10, 0);
#endif //ANDROID
ssd_widget_add (title,text);
if ( btn != NULL )
{
ssd_widget_set_click_offsets_ext( btn, -20, -20, 70, 10 );
ssd_widget_set_flags( btn, SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT );
ssd_widget_add( title, btn );
}
}
else
{
SsdWidget btn2 = ssd_button_new ("right_title_button", "", back_buttons, 2,
SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT, NULL );
ssd_widget_set_click_offsets_ext( btn2, -40, -20, 20, 10 );
ssd_widget_hide(btn2);
if ( btn != NULL )
{
ssd_widget_set_click_offsets_ext( btn, -20, -20, 70, 10 );
ssd_widget_add( title, btn );
}
#ifdef ANDROID
ssd_dialog_add_hspace (title, 10, 0);
#endif //ANDROID
ssd_widget_add (title,text);
ssd_widget_add( title, btn2 );
}
}
else
{
ssd_widget_add ( title, text );
}
#else
ssd_widget_add ( title, text );
#endif
ssd_widget_add (w, title);
}
static void roadmap_layer_reload_internal (void) {
int i;
int j;
int k;
RoadMapConfigDescriptor descriptor = ROADMAP_CONFIG_ITEM_EMPTY;
static BOOL initialized = FALSE;
const char *global_label_color, *global_label_bg_color;
global_label_color = roadmap_config_get (&RoadMapConfigLabelsColor);
global_label_bg_color = roadmap_config_get (&RoadMapConfigLabelsBgColor);
use_new_pens = FALSE;
for (i = 1; i <= RoadMapCategoryCount; ++i) {
int max_pens;
struct roadmap_canvas_category *category = RoadMapCategory + i;
const char *name = RoadMapDefaultCategoryTable[i-1];
const char *class_name;
const char *color[ROADMAP_LAYER_PENS];
const char *label_color;
int bg_color;
int thickness;
int other_pens_length = strlen(name) + 64;
char *other_pens = malloc(other_pens_length);
RoadMapClass *p;
descriptor.category = name;
descriptor.age = 0;
/* Retrieve the class of the category. */
if (!initialized) {
category->name = name;
category->visible = 1;
category->label_visible = 1;
category->label_pen = NULL;
descriptor.name = "Class";
descriptor.reference = NULL;
roadmap_config_declare ("schema", &descriptor, "", NULL);
class_name = roadmap_config_get (&descriptor);
for (p = RoadMapClasses; p->name != NULL; ++p) {
if (strcasecmp (class_name, p->name) == 0) {
p->category[p->count++] = i;
category->class_index = (int) (p - RoadMapClasses);
break;
}
}
}
/* Retrieve the category thickness & declutter. */
descriptor.name = "Thickness";
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "1", NULL);
thickness = category->thickness = roadmap_config_get_integer (&descriptor);
#if !defined (ANDROID) && !defined(J2ME)
if ( roadmap_screen_is_hd_screen() )
{
category->thickness = (int)(category->thickness * roadmap_screen_get_screen_scale() /100);
thickness = (int)(thickness * roadmap_screen_get_screen_scale() /100);
}
#endif
if (!initialized) {
descriptor.name = "Declutter";
descriptor.reference = NULL;
roadmap_config_declare
("schema", &descriptor, "2024800000", NULL);
category->declutter = roadmap_config_get_integer (&descriptor);
descriptor.name = "LabelDeclutter";
descriptor.reference = NULL;
roadmap_config_declare
("schema", &descriptor, "-1", NULL);
category->label_declutter = roadmap_config_get_integer (&descriptor);
if (category->label_declutter == -1)
category->label_declutter = category->declutter;
}
/* Retrieve the first pen's color (mandatory). */
descriptor.name = "Color";
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "black", NULL);
color[0] = roadmap_config_get (&descriptor);
/* Retrieve label color (optional) */
descriptor.name = "LabelColor";
descriptor.reference = NULL;
roadmap_config_declare ("schema", &descriptor, "", NULL);
label_color = roadmap_config_get (&descriptor);
/* Retrieve the category's other colors (optional). */
if (!editor_screen_gray_scale())
max_pens = 2;
else
max_pens = ROADMAP_LAYER_PENS;
for (j = 1; j < max_pens; ++j) {
int is_new = 0;
snprintf (other_pens, other_pens_length, "Delta%d", j);
descriptor.name = strdup(other_pens);
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "0", &is_new);
category->delta_thickness[j] =
roadmap_config_get_integer (&descriptor);
#if !defined (ANDROID) && !defined(J2ME)
if ( roadmap_screen_is_hd_screen() )
{
category->delta_thickness[j] = (int)(category->delta_thickness[j] * roadmap_screen_get_screen_scale() /100);
}
#endif
if ((j == 2) && !editor_screen_gray_scale()) break;
if (!is_new) free ((void *)descriptor.name);
if (category->delta_thickness[j] == 0) break;
snprintf (other_pens, other_pens_length, "Color%d", j);
descriptor.name = strdup(other_pens);
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "", &is_new);
color[j] = roadmap_config_get (&descriptor);
if (!is_new) free ((void *)descriptor.name);
if (*color[j] == 0) break;
}
category->pen_count = j;
if (j > RoadMapMaxUsedPen) RoadMapMaxUsedPen = j;
/* Create all necessary pens. */
for (j=0; j<LAYER_PROJ_AREAS; j++) {
snprintf (other_pens, other_pens_length, "%d%s", j, name);
category->pen[j][0] = roadmap_canvas_create_pen(other_pens,use_new_pens);
roadmap_canvas_set_thickness (category->thickness);
if (color[0] != NULL && *(color[0]) > ' ') {
roadmap_canvas_set_foreground (color[0]);
}
}
for (k=0; k<LAYER_PROJ_AREAS; k++)
for (j = 1; j < category->pen_count; ++j) {
snprintf (other_pens, other_pens_length, "%d%s%d", k, name, j);
category->pen[k][j] = roadmap_canvas_create_pen (other_pens, use_new_pens);
if (category->delta_thickness[j] < 0) {
thickness = category->thickness + category->delta_thickness[j];
} else {
thickness = category->delta_thickness[j];
}
roadmap_canvas_set_foreground (color[j]);
if (thickness > 0) {
roadmap_canvas_set_thickness (thickness);
}
}
snprintf (other_pens, other_pens_length, "%s_label_pen", name);
category->label_pen = roadmap_canvas_create_pen (other_pens,use_new_pens);
if (strlen(label_color) != 0) {
roadmap_canvas_set_foreground (label_color);
} else {
roadmap_canvas_set_foreground (global_label_color);
}
#ifdef OPENGL
bg_color = (category->pen_count > 2 ? 1 : 0);
if (color[bg_color] != NULL && *(color[bg_color]) > ' ') {
roadmap_canvas_set_background (global_label_bg_color);
}
#endif //OPENGL
free (other_pens);
}
initialized = TRUE;
}
void roadmap_canvas_agg_configure (unsigned char *buf, int width, int height, int stride) {
roadmap_log( ROADMAP_ERROR, "roadmap_canvas_agg_configure, height =%d width=%d",height, width);
agg_rbuf.attach(buf, width, height, stride);
agg_renb.attach(agg_pixf);
agg_renb.reset_clipping(true);
ras.clip_box(0, 0, agg_renb.width() - 1, agg_renb.height() - 1);
agg::glyph_rendering gren = agg::glyph_ren_outline;
agg::glyph_rendering image_gren = agg::glyph_ren_agg_gray8;
roadmap_config_declare
("preferences", &RoadMapConfigFont, "font.ttf", NULL);
roadmap_config_declare
("preferences", &RoadMapConfigFontNormal, "font_normal.ttf", NULL);
char *font_file = roadmap_path_join(roadmap_path_user(),
roadmap_config_get (&RoadMapConfigFont));
if ((width) && (height))
roadmap_screen_set_screen_type( width, height );
if (!RoadMapCanvasFontLoaded) {
if(m_feng.load_font(font_file, 0, gren) &&
m_image_feng.load_font(font_file, 0, image_gren)) {
m_feng.hinting(true);
if ( roadmap_screen_is_hd_screen() )
{
m_feng.height(22);
m_feng.width(22);
}
else
{
#ifdef _WIN32
m_feng.height(12);
m_feng.width(12);
#else
m_feng.height(15);
m_feng.width(15);
#endif
}
m_feng.flip_y(true);
m_image_feng.hinting(true);
m_image_feng.flip_y(true);
RoadMapCanvasFontLoaded = 1;
} else {
RoadMapCanvasFontLoaded = -1;
char message[300];
snprintf(message, sizeof(message), "Can't load font: %s\n", font_file);
roadmap_messagebox("Error", message);
}
}
RoadMapCanvasFontLoaded = 1;
roadmap_path_free(font_file);
font_file = roadmap_path_join(roadmap_path_user(),
roadmap_config_get (&RoadMapConfigFontNormal));
if(m_feng_nor.load_font(font_file, 0, gren) &&
m_image_feng_nor.load_font(font_file, 0, image_gren)) {
m_feng_nor.hinting(true);
if ( roadmap_screen_is_hd_screen() )
{
m_feng_nor.height(22);
m_feng_nor.width(22);
}
else
{
#ifdef _WIN32
m_feng_nor.height(12);
m_feng_nor.width(12);
#else
m_feng_nor.height(15);
m_feng_nor.width(15);
#endif
}
m_feng_nor.flip_y(true);
m_image_feng_nor.hinting(true);
m_image_feng_nor.flip_y(true);
RoadMapCanvasNormalFontLoaded = 1;
}
}
