static int
bookmarks_store_bookmarks_to_file(struct bookmarks *this_, int limit,int replace) {
FILE *f;
struct bookmark_item_priv *item,*parent_item;
char *fullname;
const char *prostr;
int result;
GHashTable *dedup=g_hash_table_new_full(g_str_hash,g_str_equal,g_free_func,NULL);
f=fopen(this_->working_file, replace ? "w+" : "a+");
if (f==NULL) {
navit_add_message(this_->parent->u.navit,"Failed to write bookmarks file");
return FALSE;
}
this_->bookmarks_list=g_list_first(this_->bookmarks_list);
while (this_->bookmarks_list) {
item=(struct bookmark_item_priv*)this_->bookmarks_list->data;
parent_item=item;
fullname=g_strdup(item->label);
while ((parent_item=parent_item->parent)) {
char *pathHelper;
if (parent_item->label) {
pathHelper=g_strconcat(parent_item->label,"/",fullname,NULL);
g_free(fullname);
fullname=g_strdup(pathHelper);
g_free(pathHelper);
dbg(1,"full name: %s\n",fullname);
}
}
if (!g_hash_table_lookup(dedup,fullname)) {
g_hash_table_insert(dedup,fullname,fullname);
if (item->type == type_bookmark) {
prostr = projection_to_name(projection_mg,NULL);
if (fprintf(f,"%s%s%s0x%x %s0x%x type=%s label=\"%s\" path=\"%s\"\n",
prostr, *prostr ? ":" : "",
item->c.x >= 0 ? "":"-", item->c.x >= 0 ? item->c.x : -item->c.x,
item->c.y >= 0 ? "":"-", item->c.y >= 0 ? item->c.y : -item->c.y,
"bookmark", item->label,fullname)<1) {
g_free(fullname);
break;
}
}
if (item->type == type_bookmark_folder) {
prostr = projection_to_name(projection_mg,NULL);
if (fprintf(f,"%s%s%s0x%x %s0x%x type=%s label=\"%s\" path=\"%s\"\n",
prostr, *prostr ? ":" : "",
"", 0,
"", 0,
"bookmark_folder", item->label,fullname)<1) {
g_free(fullname);
break;
}
}
}
/* Limit could be zero, so we start decrementing it from zero and never reach 1
or it was bigger and we decreased it earlier. So when this counter becomes 1, we know
that we have enough entries in bookmarks file */
if (limit==1) {
break;
}
limit--;
this_->bookmarks_list=g_list_next(this_->bookmarks_list);
}
fclose(f);
g_hash_table_destroy(dedup);
if (this_->mr) {
map_rect_destroy(this_->mr);
this_->mr = 0;
}
unlink(this_->bookmark_file);
result=(rename(this_->working_file,this_->bookmark_file)==0);
if (!result)
{
navit_add_message(this_->parent->u.navit,"Failed to write bookmarks file");
}
return result;
}
static void
vehicle_demo_timer(struct vehicle_priv *priv)
{
struct coord c, c2, pos, ci;
int slen, len, dx, dy;
struct route *route=NULL;
struct map *route_map=NULL;
struct map_rect *mr=NULL;
struct item *item=NULL;
len = (priv->config_speed * priv->interval / 1000)/ 3.6;
dbg(1, "###### Entering simulation loop\n");
if (!priv->config_speed)
return;
if (priv->route)
route=priv->route;
else if (priv->navit)
route=navit_get_route(priv->navit);
if (route)
route_map=route_get_map(route);
if (route_map)
mr=map_rect_new(route_map, NULL);
if (mr)
item=map_rect_get_item(mr);
if (item && item->type == type_route_start)
item=map_rect_get_item(mr);
if (item && item_coord_get(item, &pos, 1)) {
priv->position_set=0;
dbg(1, "current pos=0x%x,0x%x\n", pos.x, pos.y);
dbg(1, "last pos=0x%x,0x%x\n", priv->last.x, priv->last.y);
if (priv->last.x == pos.x && priv->last.y == pos.y) {
dbg(1, "endless loop\n");
}
priv->last = pos;
while (item && priv->config_speed) {
if (!item_coord_get(item, &c, 1)) {
item=map_rect_get_item(mr);
continue;
}
dbg(1, "next pos=0x%x,0x%x\n", c.x, c.y);
slen = transform_distance(projection_mg, &pos, &c);
dbg(1, "len=%d slen=%d\n", len, slen);
if (slen < len) {
len -= slen;
pos = c;
} else {
if (item_coord_get(item, &c2, 1) || map_rect_get_item(mr)) {
dx = c.x - pos.x;
dy = c.y - pos.y;
ci.x = pos.x + dx * len / slen;
ci.y = pos.y + dy * len / slen;
priv->direction =
transform_get_angle_delta(&pos, &c, 0);
priv->speed=priv->config_speed;
} else {
ci.x = pos.x;
ci.y = pos.y;
priv->speed=0;
dbg(0,"destination reached\n");
}
dbg(1, "ci=0x%x,0x%x\n", ci.x, ci.y);
transform_to_geo(projection_mg, &ci,
&priv->geo);
callback_list_call_attr_0(priv->cbl, attr_position_coord_geo);
break;
}
}
} else {
if (priv->position_set)
callback_list_call_attr_0(priv->cbl, attr_position_coord_geo);
}
if (mr)
map_rect_destroy(mr);
}
static void
bookmarks_load_hash(struct bookmarks *this_) {
struct bookmark_item_priv *b_item;
struct item *item;
struct attr attr;
struct coord c;
char *pos,*finder;
char *copy_helper;
if (this_->mr) {
map_rect_destroy(this_->mr);
}
this_->mr=map_rect_new(this_->bookmark, NULL);
this_->bookmarks_hash=g_hash_table_new(g_str_hash, g_str_equal);
this_->root=g_new0(struct bookmark_item_priv,1);
this_->root->type=type_none;
this_->root->parent=NULL;
this_->root->children=NULL;
bookmarks_move_root(this_);
while ((item=map_rect_get_item(this_->mr))) {
if (item->type != type_bookmark && item->type != type_bookmark_folder ) continue;
if (!item_attr_get(item, attr_path, &attr)) {
item_attr_get(item, attr_label, &attr);
}
item_coord_get(item, &c, 1);
b_item=g_new0(struct bookmark_item_priv,1);
b_item->c.x=c.x;
b_item->c.y=c.y;
b_item->label=g_strdup(attr.u.str);
b_item->type=item->type;
b_item->item=*item;
//Prepare position
bookmarks_move_root(this_);
finder=b_item->label;
while ((pos=strchr(finder,'/'))) {
*pos=0x00;
dbg(1,"Found path entry: %s\n",finder);
if (!bookmarks_move_down(this_,finder)) {
struct bookmark_item_priv *path_item=g_new0(struct bookmark_item_priv,1);
path_item->type=type_bookmark_folder;
path_item->parent=this_->current;
path_item->children=NULL;
path_item->label=g_strdup(finder);
this_->current->children=g_list_append(this_->current->children,path_item);
this_->current=path_item;
g_hash_table_insert(this_->bookmarks_hash,b_item->label,path_item);
this_->bookmarks_list=g_list_append(this_->bookmarks_list,path_item);
}
finder+=strlen(finder)+1;
}
copy_helper=g_strdup(finder);
free(b_item->label);
b_item->label=copy_helper;
b_item->parent=this_->current;
g_hash_table_insert(this_->bookmarks_hash,b_item->label,b_item);
this_->bookmarks_list=g_list_append(this_->bookmarks_list,b_item);
this_->current->children=g_list_append(this_->current->children,b_item);
this_->current->children=g_list_first(this_->current->children);
dbg(1,"Added %s to %s and current list now %u long\n",b_item->label,this_->current->label,g_list_length(this_->current->children));
}
bookmarks_move_root(this_);
}
