static void _draw_bar(SsdWidget widget, RoadMapGuiRect *rect, int flags) { static RoadMapImage bar_image = NULL; if (!bar_image) bar_image = roadmap_res_get(RES_BITMAP, RES_SKIN | RES_NOCACHE, "events_on_route_bar"); if (bar_image) { RoadMapGuiPoint sign_bottom, sign_top; RoadMapGuiPoint position; sign_top.x = rect->minx + ADJ_SCALE(15); sign_top.y = rect->miny; position.x = roadmap_canvas_image_width(bar_image) / 2; position.y = roadmap_canvas_image_height(bar_image) / 2; sign_bottom.x = rect->maxx - ADJ_SCALE(15); sign_bottom.y = rect->miny + roadmap_canvas_image_height(bar_image); if (flags & SSD_GET_SIZE) { rect->maxy = rect->miny + roadmap_canvas_image_height(bar_image) + 5; rect->minx = rect->minx + ADJ_SCALE(15); rect->maxx = rect->maxx - ADJ_SCALE(15); return; } else { roadmap_canvas_draw_image_stretch(bar_image, &sign_top, &sign_bottom, &position, 0, IMAGE_NORMAL); } } }
static int set_value (SsdWidget widget, const char *value) { struct ssd_button_data *data = (struct ssd_button_data *) widget->data; RoadMapImage bmp = NULL; int max_width = 0; int max_height = 0; int is_different = 0; int i; if (widget->value && *widget->value) free (widget->value); if (*value) widget->value = strdup(value); else widget->value = ""; if (widget->flags & SSD_VAR_SIZE) { widget->size.height = -1; widget->size.width = -1; return 0; } for (i=0; i<MAX_STATES; i++) { if (data->bitmap_images[i]) bmp = data->bitmap_images[i]; if ( !bmp ) bmp = roadmap_res_get ( RES_BITMAP, RES_SKIN, data->bitmap_names[i] ); if (!bmp) continue; if ( !max_width || !max_height ) { max_width = roadmap_canvas_image_width(bmp); max_height = roadmap_canvas_image_height(bmp); } else { int val = roadmap_canvas_image_width(bmp); if (max_width != val) { is_different = 1; if (val > max_width) max_width = val; } val = roadmap_canvas_image_height(bmp); if (max_height != val) { is_different = 1; if (val > max_height) max_height = val; } } } widget->size.height = max_height; widget->size.width = max_width; return 0; }
void roadmap_bar_draw_bottom_bar (BOOL draw_bg) { int i; int num_images; int image_width, image_height; int screen_width, screen_height; screen_width = roadmap_canvas_width (); screen_height = roadmap_canvas_height(); if (!bar_initialized) return; if (gHideBottomBar) return; image_width = roadmap_canvas_image_width(BottomBarBgImage); image_height = roadmap_canvas_image_height(BottomBarBgImage); if (BottomBarObjectTable.draw_bg && draw_bg){ num_images = screen_width / image_width; for (i = 0; i < num_images; i++){ RoadMapGuiPoint BarLocation; BarLocation.y = screen_height - image_height; BarLocation.x = i * image_width; roadmap_canvas_draw_image (BottomBarBgImage, &BarLocation, 0, IMAGE_NORMAL); } } draw_objects(&BottomBarObjectTable); }
static void _draw_alert(SsdWidget widget, RoadMapGuiRect *rect, int flags) { event_on_route_info *data = (event_on_route_info *) widget->data; RoadMapImage image; int width = widget->parent->cached_size.width - ADJ_SCALE(38); image = roadmap_res_get(RES_BITMAP, RES_SKIN, RTAlerts_Get_Map_Icon_By_Type(data->iType)); if (!image) return; if (flags & SSD_GET_SIZE) { rect->maxx = rect->minx; rect->maxy = rect->miny + roadmap_canvas_image_height(image); } else { RoadMapGuiPoint position; if (ssd_widget_rtl(NULL)) position.x = rect->minx - (width * data->iStart / 100) - roadmap_canvas_image_width(image) / 2 ; else position.x = rect->minx + (width * data->iStart / 100) - roadmap_canvas_image_width(image) / 2 + ADJ_SCALE(10); position.y = rect->miny - ADJ_SCALE(13); roadmap_canvas_draw_image(image, &position, 0, IMAGE_NORMAL); } }
int roadmap_bar_top_height(){ if (TopBarBgImage == NULL){ return 0; } else return roadmap_canvas_image_height(TopBarBgImage); }
void roadmap_splash_display (void) { #if !defined(ANDROID) && !defined(IPHONE) && !defined(GTK2_OGL) int height, width; RoadMapImage image; RoadMapGuiPoint pos; height = roadmap_canvas_height (); width = roadmap_canvas_width (); if (height > width) image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, "welcome"); else image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, "welcome_wide"); if( !image) return; pos.x = (width - roadmap_canvas_image_width(image)) / 2; pos.y = (height - roadmap_canvas_image_height(image)) / 2; roadmap_canvas_draw_image (image, &pos, 0, IMAGE_NORMAL); roadmap_canvas_free_image (image); roadmap_canvas_refresh (); #endif }
static void drawBarBGImage( const char* res, const RoadMapGuiPoint* pos ) { RoadMapImage image; int width = roadmap_canvas_width (); int height = roadmap_canvas_height(); int num_images; int image_width, image_height; int i; RoadMapGuiPoint bottom_right_pos, BarLocation; RoadMapImage bgImage = (RoadMapImage) roadmap_res_get( RES_BITMAP, RES_SKIN, res ); image_width = roadmap_canvas_image_width( bgImage ); image_height = roadmap_canvas_image_height( bgImage ); bottom_right_pos.x = roadmap_canvas_width (); bottom_right_pos.y = pos->y + image_height; #ifdef OPENGL roadmap_canvas_draw_image_scaled( bgImage, pos, &bottom_right_pos, 0, IMAGE_NORMAL ); #else num_images = width / image_width ; BarLocation.y = pos->y; for ( i = 0; i < num_images; i++ ) { BarLocation.x = pos->x + i * image_width; roadmap_canvas_draw_image( bgImage, &BarLocation, 0, IMAGE_NORMAL); } #endif }
static RoadMapImage createBGImage (RoadMapImage BarBgImage) { RoadMapImage image; int width = roadmap_canvas_width (); int height = roadmap_canvas_height(); int num_images; int image_width; int i; if (height > width){ width = width*2; } image = roadmap_canvas_new_image (width, roadmap_canvas_image_height(BarBgImage)); image_width = roadmap_canvas_image_width(BarBgImage); num_images = width / image_width ; RoadMapGuiRect *rect = malloc(sizeof(RoadMapGuiRect)); rect->minx = num_images; rect->miny = 0; // for (i = 0; i < num_images; i++){ RoadMapGuiPoint BarLocation; BarLocation.y = 0; BarLocation.x = 0;//i * image_width; roadmap_canvas_copy_image (image, &BarLocation, rect, BarBgImage ,CANVAS_COPY_NORMAL); // } return image; }
BOOL roadmap_border_initialize() { int i; for( i=0; i<border_img__count; i++) { const char* image_filename = get_img_filename(i); assert(NULL != image_filename); s_images[i].image = (RoadMapImage)roadmap_res_get( RES_BITMAP, RES_SKIN|RES_NOCACHE, image_filename); if( !s_images[i].image) { roadmap_log(ROADMAP_ERROR, "load_border_images::load_border_images() - Failed to load image file '%s.png'", image_filename); return FALSE; } s_images[i].height = roadmap_canvas_image_height(s_images[i].image); s_images[i].width = roadmap_canvas_image_width(s_images[i].image); } #ifdef __ROADMAP_BORDER_CACHE__ border_cached_table.count = 0; #endif // __ROADMAP_BORDER_CACHE__ return TRUE; }
int roadmap_bar_bottom_height(){ if (BottomBarBgImage == NULL){ return 0; } else return roadmap_canvas_image_height(BottomBarBgImage); }
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; }
int ssd_button_change_images( SsdWidget widget, RoadMapImage* bitmap_images, const char **bitmap_names, int num_bitmaps ) { int i; RoadMapImage bmp; struct ssd_button_data *data = (struct ssd_button_data *) widget->data; for (i=0; i<num_bitmaps; i++) { set_bitmap_name( data, i, bitmap_names[i] ); data->bitmap_images[i] = bitmap_images[i]; } bmp = data->bitmap_images[0]; if ( !bmp ) { bmp = roadmap_res_get ( RES_BITMAP, RES_SKIN, bitmap_names[0] ); } if ( !bmp ) { widget->size.height = widget->size.width = 0; return -1; } widget->size.height = roadmap_canvas_image_height( bmp ); widget->size.width = roadmap_canvas_image_width( bmp ); return 0; }
static RoadMapImage create_title_bar_image (RoadMapImage header_image, RoadMapGuiRect *rect) { RoadMapImage image; int width = roadmap_canvas_width (); int num_images; int image_width; RoadMapGuiPoint point; int i; image = roadmap_canvas_new_image (width, roadmap_canvas_image_height(header_image)); image_width = roadmap_canvas_image_width(header_image); num_images = width / image_width; num_images = (rect->maxx/image_width)+1; if (header_image){ for (i=0;i<=num_images;i++){ point.x = i * image_width; point.y = 0; roadmap_canvas_copy_image (image, &point, NULL, header_image, CANVAS_COPY_NORMAL); } } return image; }
void roadmap_bar_set_mode (int flags) { int x_offset; int y_offset; x_offset = 0; y_offset = roadmap_canvas_image_height (TopBarBgImage); if (flags & TOPBAR_FLAG) { roadmap_screen_obj_global_offset (x_offset, y_offset); roadmap_screen_move_center ((-y_offset / 2)+15); } if (flags & BOTTOM_BAR_FLAG){ roadmap_screen_obj_global_offset (-x_offset, -y_offset); roadmap_screen_move_center (y_offset / 2); } }
static void draw_objects(BarObjectTable_s *table){ int font_size; int i; int state, condition; RoadMapGuiPoint TextLocation; RoadMapImage image; int text_flag = ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP ; for (i=0; i < table->count; i++) { RoadMapGuiPoint ObjectLocation; RoadMapGuiPoint BgFocusLocation; if (table->object[i] == NULL) continue; if (table->object[i]->condition_fn[0]){ int j; BOOL cond = TRUE; for (j=0; j< table->object[i]->num_conditions;j++){ condition = (*table->object[i]->condition_fn[j]) (); if (condition != table->object[i]->condition_value[j]) cond = FALSE; } if (!cond) continue; } roadmap_bar_pos(table->object[i], &ObjectLocation); if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if ((state < 0) || (state >= MAX_STATES)){ } else{ if (table->object[i]->images[state] != NULL){ if (table->object[i]->image_state == IMAGE_STATE_SELECTED){ if (table->object[i]->image_selected[state] != NULL){ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->image_selected[state] ); roadmap_canvas_draw_image ( image, &ObjectLocation, 0,IMAGE_NORMAL); } else{ #ifdef TOUCH_SCREEN if (TopBarSelectedBg){ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[state] ); BgFocusLocation.x = ObjectLocation.x - (roadmap_canvas_image_width(TopBarSelectedBg) -roadmap_canvas_image_width( image ))/2; BgFocusLocation.y = ObjectLocation.y - (roadmap_canvas_image_height(TopBarSelectedBg) -roadmap_canvas_image_height( image ))/4*3; roadmap_canvas_draw_image ( TopBarSelectedBg, &BgFocusLocation, 0,IMAGE_NORMAL ); } #endif image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[state] ); roadmap_canvas_draw_image ( image, &ObjectLocation, 0,IMAGE_NORMAL); } } else{ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[state] ); roadmap_canvas_draw_image ( image, &ObjectLocation, 0,IMAGE_NORMAL); } } } } else{ if (table->object[i]->image_state == IMAGE_STATE_SELECTED){ if (table->object[i]->image_selected[0] != NULL){ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->image_selected[0] ); roadmap_canvas_draw_image ( image, &ObjectLocation, 0,IMAGE_NORMAL); } else{ #ifdef TOUCH_SCREEN if (TopBarSelectedBg){ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[0] ); BgFocusLocation.x = ObjectLocation.x - (roadmap_canvas_image_width(TopBarSelectedBg) -roadmap_canvas_image_width( image ))/2; BgFocusLocation.y = ObjectLocation.y - (roadmap_canvas_image_height(TopBarSelectedBg) -roadmap_canvas_image_height( image ))/4*3; roadmap_canvas_draw_image ( TopBarSelectedBg, &BgFocusLocation, 0,IMAGE_NORMAL ); } #endif image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[0] ); roadmap_canvas_draw_image (image, &ObjectLocation, 0,IMAGE_NORMAL); } } else if (table->object[i]->images[0] ) { image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[0] ); roadmap_canvas_draw_image ( image , &ObjectLocation, 0,IMAGE_NORMAL); } } if (table->object[i]->bar_image_fn){ const char *image_name = NULL; image_name = table->object[i]->bar_image_fn->bar_text_fn(); if (image_name && *image_name){ image = roadmap_res_get (RES_BITMAP, RES_SKIN, image_name ); if (image){ roadmap_canvas_draw_image ( image , &ObjectLocation, 0,IMAGE_NORMAL); } } } if (table->object[i]->bar_text){ if (table->object[i]->font_size != 0) font_size = table->object[i]->font_size; else font_size = 10; if (table->object[i]->text_alling != -1){ text_flag = table->object[i]->text_alling; } else if (table->object[i]->pos_x < 0){ text_flag = ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP; } if (!table->object[i]->bar_text->pen) { table->object[i]->bar_text->pen = roadmap_canvas_create_pen (table->object[i]->bar_text->name, FALSE); if (table->object[i]->text_color){ roadmap_canvas_set_foreground (table->object[i]->text_color); } } else { roadmap_canvas_select_pen (table->object[i]->bar_text->pen); } if (!table->object[i]->text_color){ if (roadmap_skin_state()) roadmap_canvas_set_foreground ("#ffffff"); else roadmap_canvas_set_foreground (table->object[i]->bar_text->default_foreground); } if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if (state >0){ if (table->object[i]->images[state]) { image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[state] ); TextLocation.x = ObjectLocation.x + roadmap_canvas_image_width( image )/2; TextLocation.y = ObjectLocation.y + roadmap_canvas_image_height( image )/2; } else roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,(*table->object[i]->bar_text->bar_text_fn)()); } } else{ if (table->object[i]->images[0]){ image = roadmap_bar_load_image( table->object[i]->name, table->object[i]->images[0] ); TextLocation.x = ObjectLocation.x + roadmap_canvas_image_width( image )/2; TextLocation.y = ObjectLocation.y + roadmap_canvas_image_height( image )/2 -2; } else roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,(*table->object[i]->bar_text->bar_text_fn)()); } } if (table->object[i]->fixed_text){ if (table->object[i]->font_size != 0) font_size = table->object[i]->font_size; else font_size = 10; if (table->object[i]->text_alling != -1){ text_flag = table->object[i]->text_alling; } else if (table->object[i]->pos_x < 0){ text_flag = ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP; } roadmap_canvas_create_pen (table->object[i]->name, FALSE); if (table->object[i]->text_color){ roadmap_canvas_set_foreground (table->object[i]->text_color); } else{ if (roadmap_skin_state()) roadmap_canvas_set_foreground ("#ffffff"); else roadmap_canvas_set_foreground ("#000000"); } if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if (state >0){ roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,table->object[i]->fixed_text); } } else{ roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,table->object[i]->fixed_text); } } } }
void roadmap_bar_initialize(void){ int width; int i; const char *cursor; RoadMapFileContext file; RoadMapImage topBarBgImg, bottomBarBgImg; TopBarObjectTable.count = 0; for (i=0; i< MAX_OBJECTS;i++){ TopBarObjectTable.object[i] = NULL; BottomBarObjectTable.object[i] = NULL; } TopBarObjectTable.draw_bg = TRUE; BottomBarObjectTable.draw_bg = TRUE; width = roadmap_canvas_width (); /* * The bar images not in cache (persistent). Possible memory optimization point * AGA */ topBarBgImg = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, TOP_BAR_IMAGE); if (topBarBgImg == NULL){ return; } TopBarBgImageSize.width = roadmap_canvas_image_width( topBarBgImg ); TopBarBgImageSize.height = roadmap_canvas_image_height( topBarBgImg ); bottomBarBgImg = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, BOTTOM_BAR_IMAGE); if (bottomBarBgImg == NULL){ return; } BottomBarBgImageSize.width = roadmap_canvas_image_width( bottomBarBgImg ); BottomBarBgImageSize.height = roadmap_canvas_image_height( bottomBarBgImg ); #ifdef TOUCH_SCREEN TopBarSelectedBg = ( RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, TOP_BAR_SELECTED_BG_IMAGE ); #endif #if ! (defined(OPENGL)) // Draw directly TopBarFullBg = createBGImage( topBarBgImg ); BottomBarFullBg = createBGImage( bottomBarBgImg ); #endif /* * Deallocate the source images */ roadmap_canvas_free_image( topBarBgImg ); roadmap_canvas_free_image( bottomBarBgImg ); // Load top bar cursor = roadmap_file_map ("skin", "top_bar", NULL, "r", &file); if (cursor == NULL){ roadmap_log (ROADMAP_ERROR, "roadmap bar top_bar file is missing"); return; } roadmap_bar_load(roadmap_file_base(file), roadmap_file_size(file), &TopBarObjectTable); roadmap_file_unmap (&file); #ifndef J2ME // Load bottom bar cursor = roadmap_file_map ("skin", "bottom_bar", NULL, "r", &file); if (cursor == NULL){ roadmap_log (ROADMAP_ERROR, "roadmap bottom top_bar file is missing"); return; } roadmap_bar_load(roadmap_file_base(file), roadmap_file_size(file), &BottomBarObjectTable); roadmap_file_unmap (&file); #endif roadmap_bar_set_mode(TOPBAR_FLAG); roadmap_pointer_register_short_click (roadmap_bar_short_click, POINTER_HIGH); roadmap_pointer_register_long_click (roadmap_bar_long_click, POINTER_HIGH); roadmap_pointer_register_pressed (roadmap_bar_obj_pressed, POINTER_HIGH); roadmap_pointer_register_drag_start (roadmap_bar_drag_start, POINTER_HIGHEST); roadmap_pointer_register_released (roadmap_bar_obj_released, POINTER_HIGH); roadmap_skin_register (roadmap_bar_switch_skins); #ifdef ANDROID roadmap_androidmenu_initialize(); #endif bar_initialized = TRUE; }
static void _draw_traffic(SsdWidget widget, RoadMapGuiRect *rect, int flags) { event_on_route_info *data = (event_on_route_info *) widget->data; static RoadMapImage events_divider; static RoadMapImage events_traffic_1 = NULL; static RoadMapImage events_traffic_2 = NULL; static RoadMapImage events_traffic_3 = NULL; RoadMapImage event_traffic; int width = widget->parent->cached_size.width - ADJ_SCALE(34); if (ssd_widget_rtl(NULL)) rect->minx -= ADJ_SCALE(17); else rect->minx += ADJ_SCALE(17); if (!events_divider) events_divider = roadmap_res_get(RES_BITMAP, RES_SKIN | RES_NOCACHE, "events_divider"); if (!events_traffic_1) events_traffic_1 = roadmap_res_get(RES_BITMAP, RES_SKIN | RES_NOCACHE, "events_traffic_1"); if (!events_traffic_2) events_traffic_2 = roadmap_res_get(RES_BITMAP, RES_SKIN | RES_NOCACHE, "events_traffic_2"); if (!events_traffic_3) events_traffic_3 = roadmap_res_get(RES_BITMAP, RES_SKIN | RES_NOCACHE, "events_traffic_3"); switch (data->iSeverity) { case JAM_TYPE_MODERATE_TRAFFIC: event_traffic = events_traffic_1; break; case JAM_TYPE_HEAVY_TRAFFIC: event_traffic = events_traffic_2; break; case JAM_TYPE_STAND_STILL_TRAFFIC: event_traffic = events_traffic_3; break; default: return; } if (flags & SSD_GET_SIZE) { rect->maxx = rect->minx;//.+ 2 ; rect->maxy = rect->miny + roadmap_canvas_image_height(events_divider); } else { if ((data->iPrecentage * width / 100) > roadmap_canvas_image_width(events_divider)*2+2) { RoadMapGuiPoint position; RoadMapGuiPoint sign_top; RoadMapGuiPoint sign_bottom; if (ssd_widget_rtl(NULL)) position.x = rect->minx - (width * data->iStart / 100) - roadmap_canvas_image_width( events_divider); else position.x = rect->minx + (width * data->iStart / 100); position.y = rect->miny; roadmap_canvas_draw_image(events_divider, &position, 0, IMAGE_NORMAL); if (ssd_widget_rtl(NULL)) position.x = rect->minx - (width * data->iStart / 100) - (width * data->iPrecentage / 100) + roadmap_canvas_image_width(events_divider); else position.x = rect->minx + (width * data->iStart / 100) + (width * data->iPrecentage / 100) - 2 * roadmap_canvas_image_width(events_divider); position.y = rect->miny; roadmap_canvas_draw_image(events_divider, &position, 0, IMAGE_NORMAL); if (ssd_widget_rtl(NULL)) sign_bottom.x = rect->minx - (width * data->iStart / 100) - roadmap_canvas_image_width( events_divider); else sign_top.x = rect->minx + (width * data->iStart / 100) + roadmap_canvas_image_width( events_divider); sign_top.y = rect->miny; position.x = roadmap_canvas_image_width(event_traffic) / 2; position.y = roadmap_canvas_image_height(event_traffic) / 2; if (ssd_widget_rtl(NULL)) sign_top.x = rect->minx - (width * data->iStart / 100) - (width * data->iPrecentage / 100) + 2 * roadmap_canvas_image_width(events_divider); else sign_bottom.x = rect->minx + (width * data->iStart / 100) + (width * data->iPrecentage / 100) - 2 * roadmap_canvas_image_width(events_divider); sign_bottom.y = rect->miny + roadmap_canvas_image_height(event_traffic); roadmap_canvas_draw_image_stretch(event_traffic, &sign_top, &sign_bottom, &position, 0, IMAGE_NORMAL); } } }
void draw_objects(BarObjectTable_s *table){ int font_size; int i; int state, condition; RoadMapGuiPoint TextLocation; int text_flag = ROADMAP_CANVAS_LEFT|ROADMAP_CANVAS_TOP ; for (i=0; i < table->count; i++) { RoadMapGuiPoint ObjectLocation; if (table->object[i] == NULL) continue; if (table->object[i]->condition_fn[0]){ int j; BOOL cond = TRUE; for (j=0; j< table->object[i]->num_conditions;j++){ condition = (*table->object[i]->condition_fn[j]) (); if (condition != table->object[i]->condition_value[j]) cond = FALSE; } if (!cond) continue; } roadmap_bar_pos(table->object[i], &ObjectLocation); if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if ((state < 0) || (state >= MAX_STATES)){ } else{ if (table->object[i]->images[state] != NULL){ if ((table->object[i]->image_state == IMAGE_STATE_SELECTED) && (table->object[i]->image_selected[state] != NULL)) roadmap_canvas_draw_image (table->object[i]->image_selected[state], &ObjectLocation, 0,IMAGE_NORMAL); else roadmap_canvas_draw_image (table->object[i]->images[state], &ObjectLocation, 0,IMAGE_NORMAL); } } } else{ if ((table->object[i]->image_state == IMAGE_STATE_SELECTED) && (table->object[i]->image_selected[0] != NULL)){ roadmap_canvas_draw_image (table->object[i]->image_selected[0], &ObjectLocation, 0,IMAGE_NORMAL); } else if (table->object[i]->images[0]) roadmap_canvas_draw_image (table->object[i]->images[0], &ObjectLocation, 0,IMAGE_NORMAL); } if (table->object[i]->bar_text){ if (table->object[i]->font_size != 0) font_size = table->object[i]->font_size; else font_size = 10; if (table->object[i]->text_alling != -1){ text_flag = table->object[i]->text_alling; } else if (table->object[i]->pos_x < 0){ text_flag = ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP; } roadmap_canvas_create_pen (table->object[i]->bar_text->name); if (table->object[i]->text_color){ roadmap_canvas_set_foreground (table->object[i]->text_color); } else{ roadmap_canvas_set_foreground (table->object[i]->bar_text->default_foreground); } if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if (state >0){ if (table->object[i]->images[state]){ TextLocation.x = ObjectLocation.x + roadmap_canvas_image_width(table->object[i]->images[state])/2; TextLocation.y = ObjectLocation.y + roadmap_canvas_image_height(table->object[i]->images[state])/2; } else roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,(*table->object[i]->bar_text->bar_text_fn)()); } } else{ if (table->object[i]->images[0]){ TextLocation.x = ObjectLocation.x + roadmap_canvas_image_width(table->object[i]->images[0])/2; TextLocation.y = ObjectLocation.y + roadmap_canvas_image_height(table->object[i]->images[0])/2 -2; } else roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,(*table->object[i]->bar_text->bar_text_fn)()); } } if (table->object[i]->fixed_text){ if (table->object[i]->font_size != 0) font_size = table->object[i]->font_size; else font_size = 10; if (table->object[i]->text_alling != -1){ text_flag = table->object[i]->text_alling; } else if (table->object[i]->pos_x < 0){ text_flag = ROADMAP_CANVAS_RIGHT|ROADMAP_CANVAS_TOP; } roadmap_canvas_create_pen (table->object[i]->name); if (table->object[i]->text_color){ roadmap_canvas_set_foreground (table->object[i]->text_color); } else{ if (roadmap_skin_state()) roadmap_canvas_set_foreground ("#ffffff"); else roadmap_canvas_set_foreground ("#000000"); } if (table->object[i]->state_fn) { state = (*table->object[i]->state_fn) (); if (state >0){ roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,table->object[i]->fixed_text); } } else{ roadmap_bar_pos(table->object[i], &TextLocation); roadmap_canvas_draw_string_size (&TextLocation, text_flag, font_size,table->object[i]->fixed_text); } } } }
// Draw the warning on the screen void roadmap_alerter_display(void) { const char * iconName; int alertId; char AlertStr[200]; RoadMapGuiPoint AlertIconLocation; int opacity; char distance_str[100]; // RoadMapGpsPosition pos; RoadMapImage theIcon; BOOL is_cancelable; AlertStr[0] = 0; if (alert_should_be_visible) { if (!alert_active && the_active_alert.alert_type == ALERT) { roadmap_alerter_audio(); } alertId = roadmap_alerter_get_active_alert_id(); is_cancelable = (* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->is_cancelable)) (alertId); if (!alert_active && is_cancelable) set_softkey(); // alert_active = TRUE; // // if (the_active_alert.alert_type == ALERT){ // iconName = (* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_alert_icon)) (alertId); // } // else { // iconName = (* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_warning_icon)) (alertId); // } // // snprintf(AlertStr + strlen(AlertStr), sizeof(AlertStr) // - strlen(AlertStr), "<b1>%s%s\n",roadmap_lang_get("Approaching"), roadmap_lang_get((* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_string)) (alertId) )); // // snprintf(AlertStr + strlen(AlertStr), sizeof(AlertStr) // - strlen(AlertStr), roadmap_lang_get("%s: %d %s\n"),roadmap_lang_get("In"), the_active_alert.distance_to_alert, roadmap_lang_get(roadmap_math_distance_unit())); // // roadmap_navigate_get_current (&pos, NULL, NULL); // snprintf(AlertStr + strlen(AlertStr), sizeof(AlertStr) // - strlen(AlertStr), roadmap_lang_get("%d %s"),roadmap_math_to_speed_unit(pos.speed), roadmap_lang_get(roadmap_math_speed_unit())); // // roadmap_display_pop_up("Approach Alert", iconName , NULL, AlertStr); alertId = roadmap_alerter_get_active_alert_id(); if (the_active_alert.alert_type == ALERT) { iconName = (* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_alert_icon)) (alertId); if (iconName == NULL) { return; } theIcon = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, iconName ); if (theIcon == NULL) { roadmap_log( ROADMAP_ERROR, "Alerts - Icon Not found (%s)", iconName); return; } alert_active = TRUE; } else { iconName = (* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_warning_icon)) (alertId); theIcon = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, iconName); if (theIcon == NULL) { roadmap_log( ROADMAP_ERROR, "Alerts - Icon Not found (%s)", iconName); return; } alert_active = TRUE; } AlertIconLocation.x = roadmap_canvas_width () - roadmap_canvas_image_width(theIcon); AlertIconLocation.y = roadmap_canvas_height ()/2 - roadmap_canvas_image_height(theIcon)/2 ; opacity = 0; sprintf(distance_str, "%d %s", the_active_alert.distance_to_alert, roadmap_math_distance_unit()); roadmap_display_text("Distance To Alert", distance_str); roadmap_canvas_draw_image (theIcon, &AlertIconLocation,opacity, IMAGE_NORMAL); } else { if (alert_active && !alert_should_be_visible) { alert_active = FALSE; if ((* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->is_cancelable)) (roadmap_alerter_get_active_alert_id())) remove_softkey(); the_active_alert.active_alert_id = -1; roadmap_display_hide("Distance To Alert"); } } }
void roadmap_display_sign_pop_up(RoadMapSign *sign) { RoadMapGuiPoint text_position; RoadMapGuiPoint top, bottom; int text_height = 0; RoadMapGuiPoint icon_screen_point; int width, ascent, descent; int lines = 1; int screen_width; int sign_width; int i; int allign = ROADMAP_CANVAS_TOPLEFT; if (ssd_widget_rtl (NULL)) allign = ROADMAP_CANVAS_TOPRIGHT; roadmap_canvas_get_text_extents (sign->content, -1, &width, &ascent, &descent, NULL); text_height = ascent + descent + 5; screen_width = roadmap_canvas_width(); for (i = 0; sign->content[i] != '\0'; i++) if (sign->content[i]=='\n') lines++; if (lines < 2) lines = 2; sign->deadline = -1; top.x = 1; top.y = roadmap_bar_top_height()+1; bottom.x = screen_width; #ifdef TOUCH_SCREEN bottom.y = (lines) * 21 + top.y + 8; sign_width = roadmap_display_border(sign->style, sign->header_type, sign->pointer_type, &bottom, &top, "#d2dfef", &sign->position,0); #else bottom.y = (lines) * 21 + top.y; sign_width = roadmap_display_border(sign->style, sign->header_type, sign->pointer_type, &bottom, &top, "#e4f1f9", &sign->position,0); #endif if (sign->image != NULL){ RoadMapImage close; RoadMapImage image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, sign->image); if (image){ if (ssd_widget_rtl (NULL)) icon_screen_point.x = top.x + 12; else icon_screen_point.x = top.x + sign_width - 12 - roadmap_canvas_image_width(image); icon_screen_point.y = bottom.y - roadmap_canvas_image_height(image) -12; roadmap_canvas_draw_image (image, &icon_screen_point, 0, IMAGE_NORMAL); } close = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, "rm_quit"); if (close){ icon_screen_point.y = top.y + 4; if (ssd_widget_rtl (NULL)) icon_screen_point.x = top.x + 2; else icon_screen_point.x = top.x + sign_width - 12 - roadmap_canvas_image_width(close); roadmap_canvas_draw_image (close, &icon_screen_point, 0, IMAGE_NORMAL); } } roadmap_canvas_select_pen (sign->foreground); if (ssd_widget_rtl (NULL)) text_position.x = sign_width - 10 ; else text_position.x = 10; #ifdef TOUCH_SCREEN text_position.y = roadmap_bar_top_height() + 5 ; #else text_position.y = roadmap_bar_top_height() + 9 ; #endif roadmap_display_string (sign->content, lines, text_height, &text_position, allign); }
static void draw (SsdWidget widget, RoadMapGuiRect *rect, int flags) { RoadMapGuiPoint points[5]; int count = 5; #ifdef OPENGL RoadMapGuiPoint position; RoadMapGuiPoint sign_bottom, sign_top; static RoadMapImage focus_image; #endif const char* background = widget->bg_color; if (!(flags & SSD_GET_SIZE)) { if (widget->in_focus && widget->focus_highlight ) background = "#b0d504"; else if (widget->background_focus) background = "#8a8a8a"; if (background) { if (widget->flags & SSD_ROUNDED_CORNERS){ RoadMapGuiRect erase_rect; erase_rect.minx = rect->minx + SSD_ROUNDED_CORNER_WIDTH; erase_rect.miny = rect->miny + SSD_ROUNDED_CORNER_HEIGHT; erase_rect.maxx = rect->maxx - SSD_ROUNDED_CORNER_WIDTH; erase_rect.maxy = rect->maxy - SSD_ROUNDED_CORNER_HEIGHT; roadmap_canvas_select_pen (bg); roadmap_canvas_set_foreground (background); //roadmap_canvas_erase_area (&erase_rect); } else{ if (!(widget->flags & SSD_DIALOG_TRANSPARENT)){ roadmap_canvas_select_pen (bg); roadmap_canvas_set_foreground (background); if ((widget->flags & SSD_CONTAINER_TXT_BOX) || (widget->flags & SSD_CONTAINER_SEARCH_BOX)){ rect->minx += 10; rect->maxx -= 10; } else roadmap_canvas_erase_area (rect); #if defined(OPENGL) && !defined(_WIN32) if (widget->in_focus && widget->focus_highlight ){ if (!focus_image) focus_image = roadmap_res_get( RES_BITMAP, RES_SKIN, "focus" ); if (focus_image){ sign_top.x = rect->minx; sign_top.y = rect->miny; position.x = roadmap_canvas_image_width(focus_image)/2; position.y = roadmap_canvas_image_height(focus_image) / 2; sign_bottom.x = rect->maxx; sign_bottom.y = rect->maxy; roadmap_canvas_draw_image_stretch( focus_image, &sign_top, &sign_bottom, &position, 0, IMAGE_NORMAL ); } } #endif } } } if ((widget->flags & SSD_SHADOW_BG) ) { draw_shadow_bg(); } if ((widget->flags & SSD_CONTAINER_TITLE) && !(widget->flags & SSD_DIALOG_FLOAT) && !(widget->flags & SSD_DIALOG_TRANSPARENT) ) { draw_bg(rect); } } if (widget->flags & SSD_CONTAINER_BORDER) { points[0].x = rect->minx + 1; #ifndef TOUCH_SCREEN points[0].y = rect->miny + 1; points[1].y = rect->miny + 1; points[4].y = rect->miny + 1; #else points[0].y = rect->miny; points[1].y = rect->miny; points[4].y = rect->miny ; #endif points[1].x = rect->maxx - 0; points[2].x = rect->maxx - 0; points[2].y = rect->maxy - 0; points[3].x = rect->minx + 1; points[3].y = rect->maxy - 0; points[4].x = rect->minx + 1; if (!(flags & SSD_GET_SIZE)) { const char *color = default_fg; RoadMapPosition *position = NULL; roadmap_canvas_select_pen (border); if (widget->fg_color) color = widget->fg_color; roadmap_canvas_set_foreground (color); if (widget->flags & SSD_ROUNDED_CORNERS){ int pointer_type = POINTER_NONE; int header_type = HEADER_NONE; int style = STYLE_NORMAL; int position_offset = widget->offset_y; #ifdef TOUCH_SCREEN widget->flags &= ~SSD_POINTER_MENU; #endif if (widget->flags & SSD_POINTER_MENU){ pointer_type = POINTER_MENU; #ifndef OPENGL points[2].y -= 17; #endif } else if (widget->flags & SSD_POINTER_COMMENT){ pointer_type = POINTER_COMMENT; #ifdef OPENGL points[2].y += 20; /* The height of the pointer */ #else points[2].y -= 7; #endif } else if (widget->flags & SSD_POINTER_NONE){ pointer_type = POINTER_NONE; if (!((widget->flags & SSD_ROUNDED_WHITE) || (widget->flags & SSD_ROUNDED_BLACK))) points[2].y -= 10; } if (widget->in_focus && widget->focus_highlight ) background = "#b0d504"; else if ((widget->flags & SSD_POINTER_COMMENT) | (widget->flags & SSD_POINTER_MENU) | (widget->flags & SSD_POINTER_NONE)) background = "#e4f1f9"; else background = "#f3f3f5"; background = "#d2dfef"; header_type = HEADER_NONE; if (widget->flags & SSD_ROUNDED_WHITE){ style = STYLE_WHITE; if (widget->in_focus && widget->focus_highlight ) background = "#b0d504"; else background = "#ffffff"; } if (widget->flags & SSD_ROUNDED_BLACK){ style = STYLE_BLACK; if (widget->in_focus && widget->focus_highlight ) background = "#b0d504"; else background = "#000000"; } if (widget->flags & SSD_POINTER_LOCATION){ if (widget->context != NULL){ pointer_type = POINTER_POSITION; position = (RoadMapPosition *)widget->context; //position_offset = ADJ_SCALE(-40); } } if (widget->flags & SSD_POINTER_FIXED_LOCATION){ if (widget->context != NULL){ pointer_type = POINTER_FIXED_POSITION; position = (RoadMapPosition *)widget->context; } } roadmap_display_border(style, header_type, pointer_type, &points[2], &points[0], background, position, position_offset); } else roadmap_canvas_draw_multiple_lines (1, &count, points, 1); } if (widget->flags & SSD_ROUNDED_CORNERS){ if (widget->flags & SSD_ROUNDED_WHITE){ rect->minx += 4; rect->miny += 4; rect->maxx -= 4; rect->maxy -= 4; } else{ rect->minx += 10; if ((widget->flags & SSD_CONTAINER_TITLE) || (widget->flags & SSD_POINTER_MENU) || (widget->flags & SSD_POINTER_NONE)) rect->miny += 10; else rect->miny += 4; rect->maxx -= 10; rect->maxy -= 10; } } else{ rect->minx += 2; rect->miny += 2; rect->maxx -= 2; rect->maxy -= 2; } } if (widget->flags & SSD_CONTAINER_TXT_BOX){ if (!(flags & SSD_GET_SIZE)){ if (background){ rect->minx -= 10; rect->maxx += 10; } draw_text_box(widget, rect); } rect->minx += 20; rect->miny += 10; rect->maxx -= 20; rect->maxy -= 10; } if (widget->flags & SSD_CONTAINER_SEARCH_BOX){ if (!(flags & SSD_GET_SIZE)){ if (background){ rect->minx -= 10; rect->maxx += 10; } draw_search_box(widget, rect); } rect->minx += 20; rect->miny += 10; rect->maxx -= 20; rect->maxy -= 10; } if (widget->flags & SSD_CONTAINER_TITLE){ ssd_widget_set_left_softkey_text(widget, widget->left_softkey); ssd_widget_set_right_softkey_text(widget, widget->right_softkey); } if ((flags & SSD_GET_CONTAINER_SIZE) && (widget->flags & SSD_CONTAINER_TITLE)) { SsdWidget title; title = ssd_widget_get (widget, "title_bar"); if (title) { SsdSize title_size; SsdSize max_size; max_size.width = rect->maxx - rect->minx + 1; max_size.height = rect->maxy - rect->miny + 1; ssd_widget_get_size (title, &title_size, &max_size); rect->miny += title_size.height; } } }
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 }
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(); }
int roadmap_display_border(int style, int header, int pointer_type, RoadMapGuiPoint *bottom, RoadMapGuiPoint *top, const char* background, RoadMapPosition *position, int position_offset_y){ //static const char *fill_bg = "#f3f3f5";// "#e4f1f9"; RoadMapPen fill_pen; int screen_width, screen_height, sign_width, sign_height; RoadMapGuiPoint right_point, left_point, start_sides_point, point, new_point; int i, num_items; int count, start_pos_x, top_height; RoadMapGuiPoint sign_bottom, sign_top; RoadMapImage image; RoadMapGuiPoint points[3]; RoadMapGuiPoint fill_points[4]; screen_width = roadmap_canvas_width(); screen_height = roadmap_canvas_height(); if (top == NULL) { sign_top.x = 1; sign_top.y = roadmap_bar_top_height(); } else{ sign_top.x = top->x ; sign_top.y = top->y ; } if (bottom == NULL) { sign_bottom.x = screen_width-1; sign_bottom.y = screen_height - roadmap_bar_bottom_height(); } else{ sign_bottom.x = bottom->x ; sign_bottom.y = bottom->y ; } if ((pointer_type == POINTER_POSITION) || (pointer_type == POINTER_FIXED_POSITION)){ roadmap_math_coordinate (position, points); roadmap_math_rotate_project_coordinate ( points ); points[0].y += position_offset_y; } sign_width = sign_bottom.x - sign_top.x; sign_height = sign_bottom.y - sign_top.y; if (header != HEADER_NONE){ image = get_image(border_top, style, header, pointer_type, bottom, top, 0); roadmap_canvas_draw_image (image, &sign_top, 0, IMAGE_NORMAL); left_point.x = sign_top.x; right_point.x = left_point.x + sign_width - s_images[header+2].width ; start_sides_point.y = sign_top.y + s_images[header].height ; top_height = s_images[header].height+7; #ifndef __ROADMAP_BORDER_CACHE__ // Release after drawing roadmap_canvas_free_image( image ); #endif } else{ RoadMapImage image; left_point.x = sign_top.x; right_point.x = sign_bottom.x - s_images[border_white_right+style].width; start_sides_point.y = sign_top.y + s_images[border_white_top_right+style].height; left_point.y = sign_top.y ; image = get_image(border_top, style, header, pointer_type, bottom, top, 0); roadmap_canvas_draw_image (image, &left_point, 0, IMAGE_NORMAL); #ifndef __ROADMAP_BORDER_CACHE__ // Release after drawing roadmap_canvas_free_image( image ); #endif right_point.y = sign_top.y; if (style == STYLE_BLACK) top_height = s_images[border_white_top+style].height+7; else top_height = s_images[border_white_top+style].height; } num_items = ( sign_height - start_sides_point.y +sign_top.y - s_images[border_white_bottom+style].height ) / s_images[border_white_right+style].height; if (num_items < 0 ) return 0; image = get_image(border_sides, style, header, pointer_type, bottom, top, 1); for (i = 0; i < num_items; i++){ point.x = left_point.x; point.y = start_sides_point.y + i*s_images[border_white_right+style].height; roadmap_canvas_draw_image (image, &point, 0, IMAGE_NORMAL); } point.y += roadmap_canvas_image_height(image)-1; #ifndef __ROADMAP_BORDER_CACHE__ // Release after drawing roadmap_canvas_free_image( image ); #endif if (pointer_type == POINTER_NONE){ RoadMapImage image; left_point.y = point.y + s_images[border_white_left+style].height ; image = get_image(border_bottom, style, header, pointer_type, bottom, top, 0); roadmap_canvas_draw_image (image, &left_point, 0, IMAGE_NORMAL); #ifndef __ROADMAP_BORDER_CACHE__ // Release after drawing roadmap_canvas_free_image( image ); #endif } else{ left_point.y = point.y + s_images[border_white_left+style].height ; roadmap_canvas_draw_image (s_images[border_white_bottom_left+style].image, &left_point, 0, IMAGE_NORMAL); right_point.y = point.y + s_images[border_white_right+style].height; roadmap_canvas_draw_image (s_images[border_white_bottom_right+style].image, &right_point, 0, IMAGE_NORMAL); if (pointer_type == POINTER_MENU) num_items = 1; else if (pointer_type == POINTER_COMMENT){ num_items = ((right_point.x - left_point.x)/s_images[border_white_bottom+style].width)/4 -2; } else if (pointer_type == POINTER_FIXED_POSITION){ int pointer_draw_offset; pointer_draw_offset = points[0].x - 15 - left_point.x; if (pointer_draw_offset+sign_top.x > sign_bottom.x-52) pointer_draw_offset = sign_bottom.x-52-sign_top.x; if (pointer_draw_offset+sign_top.x < sign_top.x+30) pointer_draw_offset = 30; num_items = (pointer_draw_offset-21)/s_images[border_white_bottom+style].width; } else if (pointer_type == POINTER_POSITION) num_items = (right_point.x - left_point.x- 100)/s_images[border_white_bottom+style].width; else num_items = ((right_point.x - left_point.x)/s_images[border_white_bottom+style].width)/2 -2; for (i = 0; i<num_items; i++){ point.x = left_point.x + s_images[border_white_bottom_left+style].width + i * s_images[border_white_bottom+style].width ; point.y = left_point.y; roadmap_canvas_draw_image (s_images[border_white_bottom+style].image, &point, 0, IMAGE_NORMAL); } if ((pointer_type == POINTER_POSITION) || (pointer_type == POINTER_FIXED_POSITION)){ int visible = roadmap_math_point_is_visible (position); if (visible){ int count = 3; RoadMapPen pointer_pen; if (points[0].y > (point.y +10) ){ points[1].x = point.x; points[1].y = point.y+s_images[border_black_bottom_no_frame].height-3; points[2].x = point.x+42; points[2].y = point.y+s_images[border_black_bottom_no_frame].height-3; pointer_pen = roadmap_canvas_create_pen ("fill_pop_up_pen"); roadmap_canvas_set_foreground("#000000"); roadmap_canvas_set_opacity(181); count = 3; roadmap_canvas_draw_multiple_polygons (1, &count, points, 1, 0); for (i=0; i<40; i++){ point.x = point.x + s_images[border_black_bottom_no_frame].width ; point.y = point.y; roadmap_canvas_draw_image (s_images[border_black_bottom_no_frame].image, &point, 0, IMAGE_NORMAL); } } } start_pos_x = point.x+1; } else{ roadmap_canvas_draw_image (s_images[pointer_type].image, &point, 0, IMAGE_NORMAL); start_pos_x = point.x + s_images[pointer_type].width; } num_items = (right_point.x - start_pos_x )/s_images[border_white_bottom+style].width ; for (i = 0; i<num_items; i++){ new_point.x = start_pos_x + i * s_images[border_white_bottom+style].width ; new_point.y = point.y; roadmap_canvas_draw_image (s_images[border_white_bottom+style].image, &new_point, 0, IMAGE_NORMAL); } } //Fill the if ((style == STYLE_NORMAL) || (style == STYLE_BLACK)){ if ((pointer_type == POINTER_POSITION) || (pointer_type == POINTER_FIXED_POSITION)|| (pointer_type == POINTER_COMMENT)) point.y -= 1; fill_points[0].x =right_point.x ; fill_points[0].y =point.y +1; fill_points[1].x =right_point.x ; fill_points[1].y = top->y + top_height -7; fill_points[2].x = left_point.x + s_images[border_white_left+style].width ; fill_points[2].y = top->y + top_height - 7; fill_points[3].x =left_point.x + s_images[border_white_left+style].width ; fill_points[3].y = point.y +1; count = 4; } else{ fill_points[0].x =right_point.x+2 ; fill_points[0].y =point.y +2; fill_points[1].x =right_point.x +2; fill_points[1].y = top->y + top_height -2; fill_points[2].x = left_point.x + s_images[border_white_left+style].width -2; fill_points[2].y = top->y + top_height - 2; fill_points[3].x =left_point.x + s_images[border_white_left+style].width -2; fill_points[3].y = point.y +2; count = 4; } fill_pen = roadmap_canvas_create_pen ("fill_pop_up_pen"); roadmap_canvas_set_foreground(background); if (style == STYLE_BLACK) roadmap_canvas_set_opacity(181); roadmap_canvas_draw_multiple_polygons (1, &count, fill_points, 1,0 ); return sign_width; }
static void draw (SsdWidget widget, RoadMapGuiRect *rect, int flags) { struct ssd_button_data *data = (struct ssd_button_data *) widget->data; RoadMapImage image = NULL; RoadMapGuiPoint point; int image_state; int state; point.x = rect->minx; point.y = rect->miny; get_state(widget, &state, &image, &image_state); if ((flags & SSD_GET_SIZE)) { if ( data->bitmap_images[state] != NULL ) image = data->bitmap_images[state]; else image = roadmap_res_get ( RES_BITMAP, RES_SKIN, data->bitmap_names[state] ); if ( !image ) image = data->bitmap_images[0]; if ( !image ) image = roadmap_res_get ( RES_BITMAP, RES_SKIN, data->bitmap_names[0] ); if (!image ) { widget->size.height = widget->size.width = 0; return; } rect->maxx = rect->minx + roadmap_canvas_image_width(image); rect->maxy = rect->miny + roadmap_canvas_image_height(image); return; } if (!image) { roadmap_log (ROADMAP_ERROR, "SSD - Can't get image for button widget: %s", widget->name); return; } switch (state) { case BUTTON_STATE_NORMAL: roadmap_canvas_draw_image (image, &point, 0, IMAGE_NORMAL); break; case BUTTON_STATE_DISABLED: roadmap_canvas_draw_image (image, &point, 0, IMAGE_NORMAL); break; case BUTTON_STATE_SELECTED: if (image_state == state) { roadmap_canvas_draw_image (image, &point, 0, IMAGE_NORMAL); } else { roadmap_canvas_draw_image (image, &point, 0, IMAGE_SELECTED); } break; } }