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 draw_search_box(SsdWidget widget, RoadMapGuiRect *rect){
int i;
int num_images;
/*
* AGA TODO:: Check if theses images should be cached for the memory optimizations
*
*/
static RoadMapImage left;
static RoadMapImage middle;
static RoadMapImage right;
RoadMapImage image_left;
RoadMapImage image_middle;
RoadMapImage image_right;
RoadMapGuiPoint point;
int width_left, width_right, width_middle;
if (!left)
left = roadmap_res_get( RES_BITMAP,
RES_SKIN|RES_NOCACHE,
"SearchBox_left");
if (!right)
right = roadmap_res_get(
RES_BITMAP,
RES_SKIN|RES_NOCACHE,
"SearchBox_right");
if (!middle)
middle = roadmap_res_get(
RES_BITMAP,
RES_SKIN|RES_NOCACHE,
"SearchBox_middle");
image_left = left;
image_right = right;
image_middle = middle;
width_left = roadmap_canvas_image_width(image_left);
width_right = roadmap_canvas_image_width(image_right);
width_middle = roadmap_canvas_image_width(image_middle);
point.x = rect->minx;
point.y = rect->miny;
roadmap_canvas_draw_image (image_left, &point, 0, IMAGE_NORMAL);
num_images = (rect->maxx - rect->minx - width_right - width_left)/width_middle;
for (i = 0; i < num_images; i++){
point.x = +rect-> minx + width_right + i * width_middle;
point.y = rect->miny;
roadmap_canvas_draw_image (image_middle, &point, 0, IMAGE_NORMAL);
}
point.x = rect->maxx - width_right;
point.y = rect->miny;
roadmap_canvas_draw_image (image_right, &point, 0, IMAGE_NORMAL);
}
void roadmap_bar_switch_skins(void){
TopBarBgImage = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, TOP_BAR_IMAGE);
BottomBarBgImage = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN|RES_NOCACHE, BOTTOM_BAR_IMAGE);
#ifdef IPHONE
roadmap_main_adjust_skin (roadmap_skin_state());
#endif //IPHONE
}
int roadmap_bar_long_click (RoadMapGuiPoint *point) {
if ( !SelectedBarObject )
return 0;
if ( SelectedBarObject->action ) {
static RoadMapSoundList list;
SelectedBarObject->image_state = IMAGE_STATE_SELECTED;
roadmap_screen_redraw();
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click");
roadmap_res_get (RES_SOUND, 0, "click");
}
roadmap_sound_play_list (list);
roadmap_screen_redraw();
(*(SelectedBarObject->action->callback)) ();
roadmap_screen_redraw();
SelectedBarObject->image_state = IMAGE_STATE_NORMAL;
}
return 1;
}
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);
}
}
}
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;
}
static int ssd_button_long_click (SsdWidget widget,
const RoadMapGuiPoint *point) {
struct ssd_button_data *data = (struct ssd_button_data *) widget->data;
static RoadMapSoundList list;
widget->force_click = FALSE;
#ifndef IPHONE
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click_long");
roadmap_res_get (RES_SOUND, 0, "click_long");
}
roadmap_sound_play_list (list);
#endif //IPHONE
if (widget->callback) {
(*widget->callback) (widget, SSD_BUTTON_LONG_CLICK);
}
data->state = BUTTON_STATE_NORMAL;
return 1;
}
static int roadmap_screen_obj_long_click (RoadMapGuiPoint *point) {
static RoadMapSoundList list;
RoadMapScreenObj object = RoadMapScreenObjSelected;
if (!RoadMapScreenObjSelected) {
return 0;
}
if (RoadMapScreenObjSelected->flags & OBJ_FLAG_REPEAT) return 1;
if (object->state_fn && (*object->state_fn)() < 0 ) return 0;
RoadMapScreenObjSelected = NULL;
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click_long");
roadmap_res_get (RES_SOUND, 0, "click_long");
}
if (object->long_action) {
roadmap_sound_play_list (list);
(*(object->long_action->callback)) ();
} else if (object->action) {
roadmap_sound_play_list (list);
(*(object->action->callback)) ();
}
return 1;
}
int roadmap_bar_short_click (RoadMapGuiPoint *point) {
BarObject *object = roadmap_bar_by_pos(point, &TopBarObjectTable);
if (!object) {
object = roadmap_bar_by_pos(point, &BottomBarObjectTable);
if (!object)
return 0;
}
if (object->action) {
static RoadMapSoundList list;
object->state = IMAGE_STATE_NORMAL;
roadmap_screen_redraw();
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click");
roadmap_res_get (RES_SOUND, 0, "click");
}
roadmap_sound_play_list (list);
roadmap_screen_redraw();
(*(object->action->callback)) ();
roadmap_screen_redraw();
}
return 1;
}
static int roadmap_ticker_short_click(RoadMapGuiPoint *point) {
static RoadMapSoundList list;
if (!gInitialized) return 0 ;
if (!gTickerOn)
return 0;
#ifdef PLAY_CLICK
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click");
roadmap_res_get (RES_SOUND, 0, "click");
}
#endif
if (gTickerOn)
if ((point->y >= (OpenIconRct.miny)) &&
(point->y <= (OpenIconRct.maxy))) {
#ifdef PLAY_CLICK
roadmap_sound_play_list (list);
#endif
roadmap_ticker_hide();
return 1;
}
return 0;
}
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;
}
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 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 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
}
void roadmap_groups_add_following_group_icon(int index, char *name){
if (name && *name){
char temp[GROUP_ICON_MAX_SIZE];
snprintf(temp, GROUP_ICON_MAX_SIZE, "wazer_%s", name);
// preload follwing groups icons
if (roadmap_res_get(RES_BITMAP,RES_SKIN, name) == NULL)
roadmap_res_download(RES_DOWNLOAD_IMAGE, name, NULL, "",FALSE, 0, NULL, NULL );
}
if (index > MAX_GROUPS)
return;
if (g_FollowingGroupIcons[index] != NULL)
free(g_FollowingGroupIcons[index]);
if (name && *name){
g_FollowingGroupIcons[index] = strdup(name);
}
else{
g_FollowingGroupIcons[index] = strdup("groups_default_icons");
}
}
void draw_title_bar(RoadMapGuiRect *rect){
static RoadMapImage header_image;
RoadMapGuiPoint point;
static RoadMapImage cached_header_image;
static int cached_width = -1;
rect->miny -= 1;
if (!header_image)
header_image = roadmap_res_get(
RES_BITMAP,
RES_SKIN|RES_NOCACHE,
"header");
point.x = rect->minx;
point.y = rect->miny;
#if defined( OPENGL )
draw_title_bar_image( header_image, rect, &point );
#else
if ((cached_header_image == NULL) || (cached_width != roadmap_canvas_width())){
if (cached_header_image != NULL)
roadmap_canvas_free_image(cached_header_image);
cached_header_image = create_title_bar_image (header_image, rect);
cached_width = roadmap_canvas_width();
}
roadmap_canvas_draw_image (cached_header_image, &point, 0, IMAGE_NORMAL);
#endif
}
void get_state (SsdWidget widget, int *state, RoadMapImage *image, int *image_state) {
struct ssd_button_data *data = (struct ssd_button_data *) widget->data;
int i;
if ((widget->in_focus ))
*state = IMAGE_SELECTED;
else
*state = data->state;
if (data->state == BUTTON_STATE_DISABLED)
*state = BUTTON_STATE_DISABLED;
for (i=*state; i>=0; i--)
{
if ( data->bitmap_images[i] )
{
*image = data->bitmap_images[i];
break;
}
else if ( ( (*image) = roadmap_res_get ( RES_BITMAP, RES_SKIN, data->bitmap_names[i] ) ) )
{
break;
}
}
*image_state = i;
}
int roadmap_bar_obj_released (RoadMapGuiPoint *point)
{
BarObject *new_bar_object = NULL;
// The release event causes the selected object in the press event to be unselected
if ( SelectedBarObject )
{
SelectedBarObject->image_state = IMAGE_STATE_NORMAL;
roadmap_pointer_unregister_drag_motion(roadmap_bar_drag_motion);
if ( !gHideTopBar )
new_bar_object = roadmap_bar_by_pos(point, &TopBarObjectTable);
if (!new_bar_object) {
if ( !gHideBottomBar )
new_bar_object = roadmap_bar_by_pos(point, &BottomBarObjectTable);
if (!new_bar_object){
SelectedBarObject = NULL;
roadmap_screen_redraw();
return 0;
}
}
if (new_bar_object != SelectedBarObject){
SelectedBarObject = NULL;
roadmap_screen_redraw();
return 1;
}
if ( SelectedBarObject->action )
{
static RoadMapSoundList list;
SelectedBarObject->image_state = IMAGE_STATE_SELECTED;
roadmap_screen_redraw();
#ifdef PLAY_CLICK
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click");
roadmap_res_get (RES_SOUND, 0, "click");
}
roadmap_sound_play_list (list);
#endif
roadmap_screen_redraw();
(*(SelectedBarObject->action->callback)) ();
roadmap_screen_redraw();
SelectedBarObject->image_state = IMAGE_STATE_NORMAL;
}
}
SelectedBarObject = NULL;
roadmap_screen_redraw();
return 1;
}
static void play_remider_sound(void){
static RoadMapSoundList list;
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, REMINDER_SOUND);
roadmap_res_get (RES_SOUND, 0, REMINDER_SOUND);
}
roadmap_sound_play_list (list);
}
static void Play_Animation_Sound (void) {
static RoadMapSoundList list;
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, ANIMATION_SOUND);
roadmap_res_get (RES_SOUND, 0, ANIMATION_SOUND);
}
roadmap_sound_play_list (list);
}
void roadmap_speedometer_initialize(void){
SpeedometerImage = (RoadMapImage) roadmap_res_get (RES_BITMAP, RES_SKIN|RES_NOCACHE, "speedometer");
if (SpeedometerImage == NULL){
roadmap_log (ROADMAP_ERROR, "Can't find speedometer resource");
return;
}
roadmap_speedometer_prev_after_refresh =
roadmap_screen_subscribe_after_refresh (roadmap_speedometer_after_refresh);
}
void roadmap_groups_set_active_group_icon(char *name){
if (name && *name){
strncpy(g_ActiveGroupIcon, name, sizeof(g_ActiveGroupIcon));
snprintf(g_ActiveGroupWazerIcon, GROUP_ICON_MAX_SIZE, "wazer_%s", name);
// preload my active groups icon
if (roadmap_res_get(RES_BITMAP,RES_SKIN, name) == NULL)
roadmap_res_download(RES_DOWNLOAD_IMAGE, name, NULL, "",FALSE, 0, NULL, NULL );
// preload my active groups wazer icon
if (roadmap_res_get(RES_BITMAP,RES_SKIN, g_ActiveGroupWazerIcon) == NULL)
roadmap_res_download(RES_DOWNLOAD_IMAGE, g_ActiveGroupWazerIcon, NULL, "",FALSE, 0, NULL, NULL );
}
else{
g_ActiveGroupIcon[0] = 0;
g_ActiveGroupWazerIcon[0] = 0;
}
}
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;
}
static RoadMapImage roadmap_bar_load_image( const char* obj_name, const char* img_name )
{
RoadMapImage image;
if (img_name == NULL)
return NULL;
image = roadmap_res_get (RES_BITMAP, RES_SKIN, img_name );
if (image == NULL) {
roadmap_log (ROADMAP_ERROR, "roadmap bar:'%s' can't load image:%s.",
obj_name, img_name );
}
return image;
}
static int ssd_button_short_click (SsdWidget widget,
const RoadMapGuiPoint *point) {
struct ssd_button_data *data = (struct ssd_button_data *) widget->data;
static RoadMapSoundList list;
if (data->state == BUTTON_STATE_DISABLED)
return 1;
widget->force_click = FALSE;
#ifdef PLAY_CLICK
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "click");
roadmap_res_get (RES_SOUND, 0, "click");
}
roadmap_sound_play_list (list);
#endif //IPHONE
#ifdef TOUCH_SCREEN
if (widget->callback == NULL){
data->state = BUTTON_STATE_NORMAL;
roadmap_screen_redraw ();
return 0;
}
else{
delayed_widget = widget;
widget->in_focus = TRUE;
data->state = BUTTON_STATE_SELECTED;
roadmap_main_set_periodic (100, button_callback);
return 1;
}
#else
if (widget->callback) {
(*widget->callback) ( widget, SSD_BUTTON_SHORT_CLICK );
return 1;
}
data->state = BUTTON_STATE_NORMAL;
roadmap_screen_redraw ();
#endif
return 0;
}
void RealTimeBonus_SegmentChangedCB (PluginLine *current, int direction){
int line_length;
RoadMapPosition pos;
line_length = roadmap_line_length(current->line_id);
if (line_length < 75)
return;
roadmap_square_set_current(current->square);
if (direction == ROUTE_DIRECTION_WITH_LINE){
roadmap_street_extend_line_ends(current, NULL, &pos, FLAG_EXTEND_TO, NULL, NULL);
}
else{
roadmap_street_extend_line_ends(current, &pos, NULL, FLAG_EXTEND_FROM, NULL, NULL);
}
if (g_CustomIndex == -1)
return;
if (gBonusTable.bonus[g_CustomIndex] == NULL)
return;
printf("CustomBonusCB %s",gBonusTable.bonus[g_CustomIndex]->pIconName);
gBonusTable.bonus[g_CustomIndex]->position.latitude = pos.latitude;
gBonusTable.bonus[g_CustomIndex]->position.longitude = pos.longitude;
//Adding the custom bonus
if (roadmap_map_settings_road_goodies()){
static RoadMapSoundList list;
if (!list) {
list = roadmap_sound_list_create (SOUND_LIST_NO_FREE);
roadmap_sound_list_add (list, "ping2");
roadmap_res_get (RES_SOUND, 0, "ping2");
}
roadmap_sound_play_list (list);
AddBonusToMap(gBonusTable.bonus[g_CustomIndex], TRUE);
}
g_CustomIndex = -1;
roadmap_navigate_unregister_segment_changed(RealTimeBonus_SegmentChangedCB);
}
void roadmap_display_image_sign(RoadMapSign *sign) {
int screen_width;
int screen_height;
RoadMapGuiPoint position;
RoadMapImage image;
screen_width = roadmap_canvas_width();
screen_height = roadmap_canvas_height();
if (sign->where == SIGN_TOP){
position.x = 3;
position.y = roadmap_bar_top_height() + 3;
}
if (sign->image != NULL){
image = (RoadMapImage) roadmap_res_get(RES_BITMAP, RES_SKIN, sign->image);
roadmap_canvas_draw_image (image, &position, 0, IMAGE_NORMAL);
}
}
static void roadmap_screen_obj_decode_icon
(RoadMapScreenObj object,
int argc, const char **argv, int *argl) {
int i;
argc -= 1;
if (object->states_count > MAX_STATES) {
roadmap_log (ROADMAP_ERROR, "screen object:'%s' has too many states.",
object->name);
return;
}
for (i = 1; i <= argc; ++i) {
RoadMapImage image = NULL;
char arg[256];
roadmap_screen_obj_decode_arg (arg, sizeof(arg), argv[i], argl[i]);
if (!object->images[object->states_count]) {
image = roadmap_res_get (RES_BITMAP, RES_SKIN, arg);
if (image == NULL) {
roadmap_log (ROADMAP_ERROR,
"screen object:'%s' can't load image:%s.",
object->name,
arg);
}
object->images[object->states_count] = image;
} else {
object->sprites[object->states_count] =
roadmap_object_string (arg, argl[i]);
}
}
++object->states_count;
}
static void roadmap_bar_decode_icon
(BarObject *object,
int argc, const char **argv, int *argl) {
int i;
argc -= 1;
if (object->states_count > MAX_STATES) {
roadmap_log (ROADMAP_ERROR, "roadmap bar:'%s' has too many states.",
object->name);
return;
}
for (i = 1; i <= argc; ++i) {
RoadMapImage image = NULL;
char arg[256];
roadmap_bar_decode_arg (arg, sizeof(arg), argv[i], argl[i]);
image = roadmap_res_get (RES_BITMAP, RES_SKIN, arg);
if (image == NULL) {
roadmap_log (ROADMAP_ERROR,
"roadmap bar:'%s' can't load image:%s.",
object->name,
arg);
}
else
if (i == 1)
object->images[object->states_count] = image;
else
object->image_selected[object->states_count] = image;
}
object->image_state = IMAGE_STATE_NORMAL;
object->states_count++;
}
int CRoadMapNativeSound::PlayList(const RoadMapSoundList list)
{
m_AudioPlayers.ResetAndDestroy(); // stop playing whatever is playing now
m_NextPlaying = 0;
m_NumReady = 0;
int listSize = roadmap_sound_list_count(list);
m_ListSize = listSize; // know how much we need to play
for (int i = 0; i < roadmap_sound_list_count(list); i++)
{//TODO load resource
const char *name = roadmap_sound_list_get (list, i);
RoadMapSound sound =
(RoadMapSound) roadmap_res_get (RES_SOUND, RES_NOCREATE, name);
if (sound) {
PlaySound (sound);
} else {
char sound_filename[MAX_SOUND_NAME];
char path_prefix[16];
snprintf( path_prefix, sizeof(path_prefix), "sound\\%s\\", roadmap_lang_get_system_lang() );
if( roadmap_construct_res_path(
sound_filename,
sizeof(sound_filename),
name,
".mp3",
path_prefix ) == KErrNone )
{
PlayFile( sound_filename );
}
}
}
if ( (list->flags & SOUND_LIST_NO_FREE) == false )
{
free (list);
}
return 0;
}
