/[zanavi_public1]/navit/navit/navit.c
ZANavi

Diff of /navit/navit/navit.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 14 Revision 27
1/**
2 * ZANavi, Zoff Android Navigation system.
3 * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * version 2 as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
1/** 20/**
2 * Navit, a modular navigation system. 21 * Navit, a modular navigation system.
3 * Copyright (C) 2005-2009 Navit Team 22 * Copyright (C) 2005-2009 Navit Team
4 * 23 *
5 * This program is free software; you can redistribute it and/or 24 * This program is free software; you can redistribute it and/or
64#include "util.h" 83#include "util.h"
65#include "messages.h" 84#include "messages.h"
66#include "vehicleprofile.h" 85#include "vehicleprofile.h"
67#include "sunriset.h" 86#include "sunriset.h"
68#include "bookmarks.h" 87#include "bookmarks.h"
88#include "map.h"
69#ifdef HAVE_API_WIN32_BASE 89#ifdef HAVE_API_WIN32_BASE
70#include <windows.h> 90#include <windows.h>
71#include "util.h" 91#include "util.h"
72#endif 92#endif
73#ifdef HAVE_API_WIN32_CE 93#ifdef HAVE_API_WIN32_CE
77/** 97/**
78 * @defgroup navit the navit core instance. navit is the object containing nearly everything: A set of maps, one or more vehicle, a graphics object for rendering the map, a gui object for displaying the user interface, a route object, a navigation object and so on. Be warned that it is theoretically possible to have more than one navit object 98 * @defgroup navit the navit core instance. navit is the object containing nearly everything: A set of maps, one or more vehicle, a graphics object for rendering the map, a gui object for displaying the user interface, a route object, a navigation object and so on. Be warned that it is theoretically possible to have more than one navit object
79 * @{ 99 * @{
80 */ 100 */
81 101
82
83struct gui *main_loop_gui; 102struct gui *main_loop_gui;
84 103
85struct attr_iter { 104struct attr_iter
105{
86 union { 106 union
107 {
87 GList *list; 108 GList *list;
88 struct mapset_handle *mapset_handle; 109 struct mapset_handle *mapset_handle;
89 } u; 110 } u;
90}; 111};
91 112
92static void navit_vehicle_update(struct navit *this_, struct navit_vehicle *nv); 113static void navit_vehicle_update(struct navit *this_, struct navit_vehicle *nv);
93static void navit_vehicle_draw(struct navit *this_, struct navit_vehicle *nv, struct point *pnt); 114static void navit_vehicle_draw(struct navit *this_, struct navit_vehicle *nv, struct point *pnt);
94static int navit_add_vehicle(struct navit *this_, struct vehicle *v);
95static int navit_set_attr_do(struct navit *this_, struct attr *attr, int init); 115static int navit_set_attr_do(struct navit *this_, struct attr *attr, int init);
96static int navit_get_cursor_pnt(struct navit *this_, struct point *p, int keep_orientation, int *dir); 116static int navit_get_cursor_pnt(struct navit *this_, struct point *p, int keep_orientation, int *dir);
97static void navit_set_cursors(struct navit *this_);
98static void navit_cmd_zoom_to_route(struct navit *this); 117static void navit_cmd_zoom_to_route(struct navit *this);
99static void navit_cmd_set_center_cursor(struct navit *this_); 118static void navit_cmd_set_center_cursor(struct navit *this_);
100static void navit_cmd_announcer_toggle(struct navit *this_); 119static void navit_cmd_announcer_toggle(struct navit *this_);
101static void navit_set_vehicle(struct navit *this_, struct navit_vehicle *nv); 120static void navit_set_vehicle(struct navit *this_, struct navit_vehicle *nv);
102 121
103int allow_gui_internal = 0; 122int allow_gui_internal = 0;
104int routing_mode = 0; 123int routing_mode = 0;
105int MYSTERY_SPEED = 2; 124int MYSTERY_SPEED = 2;
106int offline_search_filter_duplicates = 0; 125int offline_search_filter_duplicates = 0;
107int offline_search_break_searching = 0; 126int offline_search_break_searching = 0;
127char *navit_maps_dir;
128int cancel_drawing_global = 0;
129int global_speak_streetnames = 1;
130int allow_large_mapfiles = 1; // allow the use of large (>2GB) mapfiles // -> value unused for now
131int cache_size_file = 1024 * 1024 * 10; // default value was: 20971520 (~20 MB)
132int draw_polylines_fast = 0; // default: 0
133int limit_order_corrected = 4; // remain at this order level for drawing streets etc.
134int global_search_street_size_factor = 1; // make search radius for streets bigger
108 135
109struct navit *global_navit;
110
111void
112navit_add_mapset(struct navit *this_, struct mapset *ms) 136void navit_add_mapset(struct navit *this_, struct mapset *ms)
113{ 137{
114 //dbg(0,"EEnter\n"); 138 ////DBG dbg(0,"EEnter\n");
115 this_->mapsets = g_list_append(this_->mapsets, ms); 139 this_->mapsets = g_list_append(this_->mapsets, ms);
116} 140}
117 141
118struct mapset * 142struct mapset *
119navit_get_mapset(struct navit *this_) 143navit_get_mapset(struct navit *this_)
120{ 144{
121 //dbg(0,"EEnter\n"); 145 ////DBG dbg(0,"EEnter\n");
122 if(this_->mapsets){ 146 if (this_->mapsets)
147 {
123 return this_->mapsets->data; 148 return this_->mapsets->data;
124 } else { 149 }
150 else
151 {
125 dbg(0,"No mapsets enabled! Is it on purpose? Navit can't draw a map. Please check your navit.xml\n"); 152 //DBG dbg(0,"No mapsets enabled! Is it on purpose? Navit can't draw a map. Please check your navit.xml\n");
126 } 153 }
127 return NULL; 154 return NULL;
128} 155}
129 156
130struct tracking * 157struct tracking *
131navit_get_tracking(struct navit *this_) 158navit_get_tracking(struct navit *this_)
132{ 159{
133 //dbg(0,"EEnter\n"); 160 ////DBG dbg(0,"EEnter\n");
134 return this_->tracking; 161 return this_->tracking;
135} 162}
136 163
137/** 164/**
138 * @brief Get the user data directory. 165 * @brief Get the user data directory.
143 * returns the directory used to store user data files (center.txt, 170 * returns the directory used to store user data files (center.txt,
144 * destination.txt, bookmark.txt, ...) 171 * destination.txt, bookmark.txt, ...)
145 * 172 *
146 */ 173 */
147char* 174char*
148navit_get_user_data_directory(int create) { 175navit_get_user_data_directory(int create)
176{
149 //dbg(0,"EEnter\n"); 177 ////DBG dbg(0,"EEnter\n");
150 char *dir; 178 char *dir;
151 dir = getenv("NAVIT_USER_DATADIR"); 179 dir = getenv("NAVIT_USER_DATADIR");
152 if (create && !file_exists(dir)) { 180 if (create && !file_exists(dir))
181 {
153 dbg(0,"creating dir %s\n", dir); 182 //DBG dbg(0, "creating dir %s\n", dir);
154 if (file_mkdir(dir,0)) { 183 if (file_mkdir(dir, 0))
184 {
155 dbg(0,"failed creating dir %s\n", dir); 185 //DBG dbg(0, "failed creating dir %s\n", dir);
156 return NULL; 186 return NULL;
157 } 187 }
158 } 188 }
159 return dir; 189 return dir;
160} /* end: navit_get_user_data_directory(gboolean create) */ 190} /* end: navit_get_user_data_directory(gboolean create) */
161 191
162
163void
164navit_draw_async(struct navit *this_, int async) 192void navit_draw_async(struct navit *this_, int async)
165{ 193{
166 //dbg(0,"EEnter this_->blocked=%d\n",this_->blocked); 194 //DBG dbg(0,"EEnter this_->blocked=%d\n",this_->blocked);
167 if (this_->blocked) 195 if (this_->blocked)
168 { 196 {
169 this_->blocked |= 2; 197 this_->blocked |= 2;
170 //dbg(0,"set this_->blocked=%d\n",this_->blocked); 198 ////DBG dbg(0,"set this_->blocked=%d\n",this_->blocked);
171 return; 199 return;
172 } 200 }
173 transform_setup_source_rect(this_->trans); 201 transform_setup_source_rect(this_->trans);
174 graphics_draw(this_->gra, this_->displaylist, this_->mapsets->data, this_->trans, this_->layout_current, async, NULL, this_->graphics_flags|1); 202 graphics_draw(this_->gra, this_->displaylist, this_->mapsets->data, this_->trans, this_->layout_current, async, NULL, this_->graphics_flags | 1);
175} 203}
176 204
177void
178navit_draw(struct navit *this_) 205void navit_draw(struct navit *this_)
179{ 206{
180 //dbg(0,"EEnter this_->ready=%d\n",this_->ready); 207 ////DBG dbg(0,"EEnter this_->ready=%d\n",this_->ready);
181 if (this_->ready == 3) 208 if (this_->ready == 3)
182 { 209 {
183 //dbg(0,"navit_draw_async_001\n"); 210 ////DBG dbg(0,"navit_draw_async_001\n");
184 navit_draw_async(this_, 0); 211 navit_draw_async(this_, 0);
185 } 212 }
186} 213}
187 214
188int
189navit_get_ready(struct navit *this_) 215int navit_get_ready(struct navit *this_)
190{ 216{
191 //dbg(0,"EEnter\n"); 217 ////DBG dbg(0,"EEnter\n");
192 return this_->ready; 218 return this_->ready;
193} 219}
194 220
195
196
197void
198navit_draw_displaylist(struct navit *this_) 221void navit_draw_displaylist(struct navit *this_)
199{ 222{
200 //dbg(0,"EEnter\n"); 223 ////DBG dbg(0,"EEnter\n");
201 if (this_->ready == 3) 224 if (this_->ready == 3)
202 { 225 {
203 // dbg(0,"call graphics_displaylist_draw 2") 226 // //DBG dbg(0,"call graphics_displaylist_draw 2")
204 graphics_displaylist_draw(this_->gra, this_->displaylist, this_->trans, this_->layout_current, this_->graphics_flags|1); 227 graphics_displaylist_draw(this_->gra, this_->displaylist, this_->trans, this_->layout_current, this_->graphics_flags | 1);
205 } 228 }
206} 229}
207 230
208static void
209navit_map_progress(struct navit *this_) 231static void navit_map_progress(struct navit *this_)
210{ 232{
211 //dbg(0,"EEnter\n"); 233 ////DBG dbg(0,"EEnter\n");
212 struct map *map; 234 struct map *map;
213 struct mapset *ms; 235 struct mapset *ms;
214 struct mapset_handle *msh; 236 struct mapset_handle *msh;
215 struct attr attr; 237 struct attr attr;
216 struct point p; 238 struct point p;
217 if (this_->ready != 3) 239 if (this_->ready != 3)
218 return; 240 return;
219 p.x=10; 241 p.x = 10;
220 p.y=32; 242 p.y = 32;
221 243
222 ms=this_->mapsets->data; 244 ms = this_->mapsets->data;
223 msh=mapset_open(ms); 245 msh = mapset_open(ms);
224 while (msh && (map=mapset_next(msh, 0))) { 246 while (msh && (map = mapset_next(msh, 0)))
247 {
225 if (map_get_attr(map, attr_progress, &attr, NULL)) { 248 if (map_get_attr(map, attr_progress, &attr, NULL))
249 {
226 char *str=g_strdup_printf("%s ",attr.u.str); 250 char *str = g_strdup_printf("%s ", attr.u.str);
227 graphics_draw_mode(this_->gra, draw_mode_begin); 251 graphics_draw_mode(this_->gra, draw_mode_begin);
228 graphics_draw_text_std(this_->gra, 16, str, &p); 252 graphics_draw_text_std(this_->gra, 16, str, &p);
229 g_free(str); 253 g_free(str);
230 p.y+=32; 254 p.y += 32;
231 graphics_draw_mode(this_->gra, draw_mode_end); 255 graphics_draw_mode(this_->gra, draw_mode_end);
232 } 256 }
233 } 257 }
234 mapset_close(msh); 258 mapset_close(msh);
235} 259}
236 260
237static void
238navit_redraw_route(struct navit *this_, struct route *route, struct attr *attr) 261static void navit_redraw_route(struct navit *this_, struct route *route, struct attr *attr)
239{ 262{
240 //dbg(0,"EEnter\n"); 263 ////DBG dbg(0,"EEnter\n");
241 int updated; 264 int updated;
242 265
243 if ((this_->route)&&(this_->route->route_status_was_updated == 1)) 266 if ((this_->route) && (this_->route->route_status_was_updated == 1))
244 { 267 {
245 this_->route->route_status_was_updated=0; 268 this_->route->route_status_was_updated = 0;
246 // send route_status to java 269 // send route_status to java
247#ifdef HAVE_API_ANDROID 270#ifdef HAVE_API_ANDROID
248 android_return_generic_int(1, this_->route->route_status); 271 android_return_generic_int(1, this_->route->route_status);
249#endif 272#endif
250 } 273 }
251 274
252 if (attr->type != attr_route_status) 275 if (attr->type != attr_route_status)
253 { 276 {
254 //dbg(0,"ret 1\n"); 277 ////DBG dbg(0,"ret 1\n");
255 return; 278 return;
256 } 279 }
257 updated=attr->u.num; 280 updated = attr->u.num;
258 //dbg(0,"updated=%d\n", updated); 281 ////DBG dbg(0,"updated=%d\n", updated);
259 if (this_->ready != 3) 282 if (this_->ready != 3)
260 { 283 {
261 //dbg(0,"ret 2\n"); 284 ////DBG dbg(0,"ret 2\n");
262 return; 285 return;
263 } 286 }
264 if (updated != route_status_path_done_new) 287 if (updated != route_status_path_done_new)
265 { 288 {
266 //dbg(0,"ret 3\n"); 289 ////DBG dbg(0,"ret 3\n");
267 return; 290 return;
268 } 291 }
269 if (this_->vehicle) 292 if (this_->vehicle)
270 { 293 {
271 if (this_->vehicle->follow_curr == 1) 294 if (this_->vehicle->follow_curr == 1)
272 { 295 {
273 //dbg(0,"ret 4\n"); 296 ////DBG dbg(0,"ret 4\n");
274 //dbg(0,"disabled -> we want redraw!!\n"); 297 ////DBG dbg(0,"disabled -> we want redraw!!\n");
275 // return; 298 // return;
276 } 299 }
277 if (this_->vehicle->follow_curr <= this_->vehicle->follow) 300 if (this_->vehicle->follow_curr <= this_->vehicle->follow)
278 { 301 {
279 this_->vehicle->follow_curr=this_->vehicle->follow; 302 this_->vehicle->follow_curr = this_->vehicle->follow;
280 }
281 } 303 }
304 }
282 //dbg(0,"draw s*\n"); 305 ////DBG dbg(0,"draw s*\n");
283 navit_draw(this_); 306 navit_draw(this_);
284 //dbg(0,"draw e*\n"); 307 ////DBG dbg(0,"draw e*\n");
285} 308}
286 309
287void
288navit_handle_resize(struct navit *this_, int w, int h) 310void navit_handle_resize(struct navit *this_, int w, int h)
289{ 311{
290 //dbg(0,"EEnter\n"); 312 //DBG dbg(0,"EEnter\n");
291 struct map_selection sel; 313 struct map_selection sel;
292 int callback=(this_->ready == 1); 314 int callback = (this_->ready == 1);
293 //dbg(0,"pre this_->ready=%d\n",this_->ready); 315 ////DBG dbg(0,"pre this_->ready=%d\n",this_->ready);
294 this_->ready |= 2; 316 this_->ready |= 2;
295 //dbg(0,"set this_->ready=%d\n",this_->ready); 317 ////DBG dbg(0,"set this_->ready=%d\n",this_->ready);
296 memset(&sel, 0, sizeof(sel)); 318 memset(&sel, 0, sizeof(sel));
297 this_->w=w; 319 this_->w = w;
298 this_->h=h; 320 this_->h = h;
299 sel.u.p_rect.rl.x=w; 321 sel.u.p_rect.rl.x = w;
300 sel.u.p_rect.rl.y=h; 322 sel.u.p_rect.rl.y = h;
301 transform_set_screen_selection(this_->trans, &sel); 323 transform_set_screen_selection(this_->trans, &sel);
302 graphics_init(this_->gra); 324 graphics_init(this_->gra);
303 graphics_set_rect(this_->gra, &sel.u.p_rect); 325 graphics_set_rect(this_->gra, &sel.u.p_rect);
304 if (callback) 326 if (callback)
327 {
328 //DBG dbg(0,"callback do\n");
305 callback_list_call_attr_1(this_->attr_cbl, attr_graphics_ready, this_); 329 callback_list_call_attr_1(this_->attr_cbl, attr_graphics_ready, this_);
330 }
306 if (this_->ready == 3) 331 if (this_->ready == 3)
307 { 332 {
308 //dbg(0,"navit_draw_async_002\n"); 333 //DBG dbg(0,"navit_draw_async_002\n");
309 navit_draw_async(this_, 1); 334 navit_draw_async(this_, 1);
310 } 335 }
311} 336}
312 337
313static void
314navit_resize(void *data, int w, int h) 338void navit_resize(void *data, int w, int h)
315{ 339{
316 //dbg(0,"EEnter\n"); 340 //DBG dbg(0,"EEnter %p\n", data);
317 struct navit *this=data; 341 struct navit *this = data;
318 if (!this->ignore_graphics_events) 342 if (!this->ignore_graphics_events)
343 {
344 //DBG dbg(0,"11\n");
319 navit_handle_resize(this, w, h); 345 navit_handle_resize(this, w, h);
346 }
320} 347}
321 348
322int
323navit_get_width(struct navit *this_) 349int navit_get_width(struct navit *this_)
324{ 350{
325 //dbg(0,"EEnter\n"); 351 ////DBG dbg(0,"EEnter\n");
326 return this_->w; 352 return this_->w;
327} 353}
328 354
329
330int
331navit_get_height(struct navit *this_) 355int navit_get_height(struct navit *this_)
332{ 356{
333 //dbg(0,"EEnter\n"); 357 ////DBG dbg(0,"EEnter\n");
334 return this_->h; 358 return this_->h;
335} 359}
336 360
337static void
338navit_popup(void *data) 361static void navit_popup(void *data)
339{ 362{
340 //dbg(0,"EEnter\n"); 363 ////DBG dbg(0,"EEnter\n");
341 struct navit *this_=data; 364 struct navit *this_ = data;
342 popup(this_, 1, &this_->pressed); 365 popup(this_, 1, &this_->pressed);
343 this_->button_timeout=NULL; 366 this_->button_timeout = NULL;
344 this_->popped=1; 367 this_->popped = 1;
345} 368}
346 369
347
348int
349navit_ignore_button(struct navit *this_) 370int navit_ignore_button(struct navit *this_)
350{ 371{
351 //dbg(0,"EEnter\n"); 372 ////DBG dbg(0,"EEnter\n");
352 if (this_->ignore_button) 373 if (this_->ignore_button)
353 return 1; 374 return 1;
354 this_->ignore_button=1; 375 this_->ignore_button = 1;
355 return 0; 376 return 0;
356} 377}
357 378
358void
359navit_ignore_graphics_events(struct navit *this_, int ignore) 379void navit_ignore_graphics_events(struct navit *this_, int ignore)
360{ 380{
361 //dbg(0,"EEnter\n"); 381 ////DBG dbg(0,"EEnter\n");
362 this_->ignore_graphics_events=ignore; 382 this_->ignore_graphics_events = ignore;
363} 383}
364 384
365static void
366update_transformation(struct transformation *tr, struct point *old, struct point *new, struct point *rot) 385static void update_transformation(struct transformation *tr, struct point *old, struct point *new, struct point *rot)
367{ 386{
368 //dbg(0,"EEnter\n"); 387 ////DBG dbg(0,"EEnter\n");
369 struct coord co,cn; 388 struct coord co, cn;
370 struct coord c,*cp; 389 struct coord c, *cp;
371 int yaw; 390 int yaw;
372 double angleo,anglen; 391 double angleo, anglen;
373 392
374 if (!transform_reverse(tr, old, &co)) 393 if (!transform_reverse(tr, old, &co))
375 return; 394 return;
376 if (rot) { 395 if (rot)
396 {
377 angleo=atan2(old->y-rot->y, old->x-rot->x)*180/M_PI; 397 angleo = atan2(old->y - rot->y, old->x - rot->x) * 180 / M_PI;
378 anglen=atan2(new->y-rot->y, new->x-rot->x)*180/M_PI; 398 anglen = atan2(new->y - rot->y, new->x - rot->x) * 180 / M_PI;
379 yaw=transform_get_yaw(tr)+angleo-anglen; 399 yaw = transform_get_yaw(tr) + angleo - anglen;
380 transform_set_yaw(tr, yaw % 360); 400 transform_set_yaw(tr, yaw % 360);
381 } 401 }
382 if (!transform_reverse(tr, new, &cn)) 402 if (!transform_reverse(tr, new, &cn))
383 return; 403 return;
384 cp=transform_get_center(tr); 404 cp = transform_get_center(tr);
385 c.x=cp->x+co.x-cn.x; 405 c.x = cp->x + co.x - cn.x;
386 c.y=cp->y+co.y-cn.y; 406 c.y = cp->y + co.y - cn.y;
387 dbg(1,"from 0x%x,0x%x to 0x%x,0x%x\n", cp->x, cp->y, c.x, c.y); 407 // dbg(1, "from 0x%x,0x%x to 0x%x,0x%x\n", cp->x, cp->y, c.x, c.y);
388 transform_set_center(tr, &c); 408 transform_set_center(tr, &c);
389} 409}
390 410
391void
392navit_set_timeout(struct navit *this_) 411void navit_set_timeout(struct navit *this_)
393{ 412{
394 //dbg(0,"EEnter\n"); 413 ////DBG dbg(0,"EEnter\n");
395 struct attr follow; 414 struct attr follow;
396 follow.type=attr_follow; 415 follow.type = attr_follow;
397 follow.u.num=this_->center_timeout; 416 follow.u.num = this_->center_timeout;
398 navit_set_attr(this_, &follow); 417 navit_set_attr(this_, &follow);
399} 418}
400 419
401int
402navit_handle_button(struct navit *this_, int pressed, int button, struct point *p, struct callback *popup_callback) 420int navit_handle_button(struct navit *this_, int pressed, int button, struct point *p, struct callback *popup_callback)
403{ 421{
404 //dbg(0,"EEnter\n"); 422 ////DBG dbg(0,"EEnter\n");
405 int border=16; 423 int border = 16;
406 424
407 dbg(1,"enter %d %d (ignore %d)\n",pressed,button,this_->ignore_button); 425 // dbg(1, "enter %d %d (ignore %d)\n", pressed, button, this_->ignore_button);
408 callback_list_call_attr_4(this_->attr_cbl, attr_button, this_, GINT_TO_POINTER(pressed), GINT_TO_POINTER(button), p); 426 callback_list_call_attr_4(this_->attr_cbl, attr_button, this_, GINT_TO_POINTER(pressed), GINT_TO_POINTER(button), p);
409 if (this_->ignore_button) { 427 if (this_->ignore_button)
428 {
410 this_->ignore_button=0; 429 this_->ignore_button = 0;
411 return 0; 430 return 0;
412 } 431 }
413 if (pressed) { 432 if (pressed)
433 {
414 this_->pressed=*p; 434 this_->pressed = *p;
415 this_->last=*p; 435 this_->last = *p;
416 this_->zoomed=0; 436 this_->zoomed = 0;
417 if (button == 1) { 437 if (button == 1)
438 {
418 this_->button_pressed=1; 439 this_->button_pressed = 1;
419 this_->moved=0; 440 this_->moved = 0;
420 this_->popped=0; 441 this_->popped = 0;
421 if (popup_callback) 442 if (popup_callback)
422 this_->button_timeout=event_add_timeout(500, 0, popup_callback); 443 this_->button_timeout = event_add_timeout(500, 0, popup_callback);
423 } 444 }
424 if (button == 2) 445 if (button == 2)
425 navit_set_center_screen(this_, p, 1); 446 navit_set_center_screen(this_, p, 1);
426 if (button == 3) 447 if (button == 3)
427 popup(this_, button, p); 448 popup(this_, button, p);
428 if (button == 4 && this_->use_mousewheel) { 449 if (button == 4 && this_->use_mousewheel)
450 {
429 this_->zoomed = 1; 451 this_->zoomed = 1;
430 navit_zoom_in(this_, 2, p); 452 navit_zoom_in(this_, 2, p);
431 } 453 }
432 if (button == 5 && this_->use_mousewheel) { 454 if (button == 5 && this_->use_mousewheel)
455 {
433 this_->zoomed = 1; 456 this_->zoomed = 1;
434 navit_zoom_out(this_, 2, p); 457 navit_zoom_out(this_, 2, p);
435 } 458 }
436 } else { 459 }
460 else
461 {
437 462
438 this_->button_pressed=0; 463 this_->button_pressed = 0;
439 if (this_->button_timeout) { 464 if (this_->button_timeout)
465 {
440 event_remove_timeout(this_->button_timeout); 466 event_remove_timeout(this_->button_timeout);
441 this_->button_timeout=NULL; 467 this_->button_timeout = NULL;
442 if (! this_->moved && ! transform_within_border(this_->trans, p, border)) { 468 if (!this_->moved && !transform_within_border(this_->trans, p, border))
469 {
443 navit_set_center_screen(this_, p, !this_->zoomed); 470 navit_set_center_screen(this_, p, !this_->zoomed);
444 } 471 }
445 } 472 }
446 if (this_->motion_timeout) { 473 if (this_->motion_timeout)
474 {
447 event_remove_timeout(this_->motion_timeout); 475 event_remove_timeout(this_->motion_timeout);
448 this_->motion_timeout=NULL; 476 this_->motion_timeout = NULL;
449 } 477 }
450 if (this_->moved) { 478 if (this_->moved)
479 {
451 struct point pr; 480 struct point pr;
452 pr.x=this_->w/2; 481 pr.x = this_->w / 2;
453 pr.y=this_->h; 482 pr.y = this_->h;
454#if 0 483#if 0
455 update_transformation(this_->trans, &this_->pressed, p, &pr); 484 update_transformation(this_->trans, &this_->pressed, p, &pr);
456#else 485#else
457 update_transformation(this_->trans, &this_->pressed, p, NULL); 486 update_transformation(this_->trans, &this_->pressed, p, NULL);
458#endif 487#endif
459 graphics_draw_drag(this_->gra, NULL); 488 graphics_draw_drag(this_->gra, NULL);
460 transform_copy(this_->trans, this_->trans_cursor); 489 transform_copy(this_->trans, this_->trans_cursor);
461 graphics_overlay_disable(this_->gra, 0); 490 graphics_overlay_disable(this_->gra, 0);
462 if (!this_->zoomed) 491 if (!this_->zoomed)
463 navit_set_timeout(this_); 492 navit_set_timeout(this_);
464 navit_draw(this_); 493 navit_draw(this_);
494 }
465 } else 495 else
466 return 1; 496 return 1;
467 } 497 }
468 return 0; 498 return 0;
469} 499}
470 500
471static void
472navit_button(void *data, int pressed, int button, struct point *p) 501static void navit_button(void *data, int pressed, int button, struct point *p)
473{ 502{
474 //dbg(0,"EEnter\n"); 503 ////DBG dbg(0,"EEnter\n");
475 struct navit *this=data; 504 struct navit *this = data;
476 dbg(1,"enter %d %d ignore %d\n",pressed,button,this->ignore_graphics_events); 505 // dbg(1, "enter %d %d ignore %d\n", pressed, button, this->ignore_graphics_events);
477 if (!this->ignore_graphics_events) { 506 if (!this->ignore_graphics_events)
507 {
478 if (! this->popup_callback) 508 if (!this->popup_callback)
479 this->popup_callback=callback_new_1(callback_cast(navit_popup), this); 509 this->popup_callback = callback_new_1(callback_cast(navit_popup), this);
480 navit_handle_button(this, pressed, button, p, this->popup_callback); 510 navit_handle_button(this, pressed, button, p, this->popup_callback);
481 } 511 }
482} 512}
483 513
484
485static void
486navit_motion_timeout(struct navit *this_) 514static void navit_motion_timeout(struct navit *this_)
487{ 515{
488 //dbg(0,"EEnter\n"); 516 ////DBG dbg(0,"EEnter\n");
489 int dx, dy; 517 int dx, dy;
490 518
491 if (this_->drag_bitmap) { 519 if (this_->drag_bitmap)
520 {
492 struct point point; 521 struct point point;
493 point.x=(this_->current.x-this_->pressed.x); 522 point.x = (this_->current.x - this_->pressed.x);
494 point.y=(this_->current.y-this_->pressed.y); 523 point.y = (this_->current.y - this_->pressed.y);
495 if (graphics_draw_drag(this_->gra, &point)) { 524 if (graphics_draw_drag(this_->gra, &point))
525 {
496 graphics_overlay_disable(this_->gra, 1); 526 graphics_overlay_disable(this_->gra, 1);
497 graphics_draw_mode(this_->gra, draw_mode_end); 527 graphics_draw_mode(this_->gra, draw_mode_end);
498 this_->moved=1; 528 this_->moved = 1;
499 this_->motion_timeout=NULL; 529 this_->motion_timeout = NULL;
500 return; 530 return;
501 } 531 }
502 } 532 }
503 dx=(this_->current.x-this_->last.x); 533 dx = (this_->current.x - this_->last.x);
504 dy=(this_->current.y-this_->last.y); 534 dy = (this_->current.y - this_->last.y);
505 if (dx || dy) { 535 if (dx || dy)
536 {
506 struct transformation *tr; 537 struct transformation *tr;
507 struct point pr; 538 struct point pr;
508 this_->last=this_->current; 539 this_->last = this_->current;
509 graphics_overlay_disable(this_->gra, 1); 540 graphics_overlay_disable(this_->gra, 1);
510 tr=transform_dup(this_->trans); 541 tr = transform_dup(this_->trans);
511 pr.x=this_->w/2; 542 pr.x = this_->w / 2;
512 pr.y=this_->h; 543 pr.y = this_->h;
513#if 0 544#if 0
514 update_transformation(tr, &this_->pressed, &this_->current, &pr); 545 update_transformation(tr, &this_->pressed, &this_->current, &pr);
515#else 546#else
516 update_transformation(tr, &this_->pressed, &this_->current, NULL); 547 update_transformation(tr, &this_->pressed, &this_->current, NULL);
517#endif 548#endif
518#if 0 549#if 0
519 graphics_displaylist_move(this_->displaylist, dx, dy); 550 graphics_displaylist_move(this_->displaylist, dx, dy);
520#endif 551#endif
521 graphics_draw_cancel(this_->gra, this_->displaylist); 552 graphics_draw_cancel(this_->gra, this_->displaylist);
522 // dbg(0,"call graphics_displaylist_draw 1") 553 // //DBG dbg(0,"call graphics_displaylist_draw 1")
523 graphics_displaylist_draw(this_->gra, this_->displaylist, tr, this_->layout_current, this_->graphics_flags); 554 graphics_displaylist_draw(this_->gra, this_->displaylist, tr, this_->layout_current, this_->graphics_flags);
524 transform_destroy(tr); 555 transform_destroy(tr);
525 this_->moved=1; 556 this_->moved = 1;
526 } 557 }
527 this_->motion_timeout=NULL; 558 this_->motion_timeout = NULL;
528 return; 559 return;
529} 560}
530 561
531void
532navit_handle_motion(struct navit *this_, struct point *p) 562void navit_handle_motion(struct navit *this_, struct point *p)
533{ 563{
534 //dbg(0,"EEnter\n"); 564 ////DBG dbg(0,"EEnter\n");
535 int dx, dy; 565 int dx, dy;
536 566
537 if (this_->button_pressed && !this_->popped) { 567 if (this_->button_pressed && !this_->popped)
568 {
538 dx=(p->x-this_->pressed.x); 569 dx = (p->x - this_->pressed.x);
539 dy=(p->y-this_->pressed.y); 570 dy = (p->y - this_->pressed.y);
540 if (dx < -8 || dx > 8 || dy < -8 || dy > 8) { 571 if (dx < -8 || dx > 8 || dy < -8 || dy > 8)
572 {
541 this_->moved=1; 573 this_->moved = 1;
542 if (this_->button_timeout) { 574 if (this_->button_timeout)
575 {
543 event_remove_timeout(this_->button_timeout); 576 event_remove_timeout(this_->button_timeout);
544 this_->button_timeout=NULL; 577 this_->button_timeout = NULL;
545 } 578 }
546 this_->current=*p; 579 this_->current = *p;
547 if (! this_->motion_timeout_callback) 580 if (!this_->motion_timeout_callback)
548 this_->motion_timeout_callback=callback_new_1(callback_cast(navit_motion_timeout), this_); 581 this_->motion_timeout_callback = callback_new_1(callback_cast(navit_motion_timeout), this_);
549 if (! this_->motion_timeout) 582 if (!this_->motion_timeout)
550 this_->motion_timeout=event_add_timeout(100, 0, this_->motion_timeout_callback); 583 this_->motion_timeout = event_add_timeout(100, 0, this_->motion_timeout_callback);
551 }
552 } 584 }
585 }
553} 586}
554 587
555static void
556navit_motion(void *data, struct point *p) 588static void navit_motion(void *data, struct point *p)
557{ 589{
558 //dbg(0,"EEnter\n"); 590 ////DBG dbg(0,"EEnter\n");
559 struct navit *this=data; 591 struct navit *this = data;
560 if (!this->ignore_graphics_events) 592 if (!this->ignore_graphics_events)
561 navit_handle_motion(this, p); 593 navit_handle_motion(this, p);
562} 594}
563 595
564static void
565navit_predraw(struct navit *this_) 596static void navit_predraw(struct navit *this_)
566{ 597{
567 //dbg(0,"EEnter\n"); 598 ////DBG dbg(0,"EEnter\n");
568 GList *l; 599 GList *l;
569 struct navit_vehicle *nv; 600 struct navit_vehicle *nv;
570 transform_copy(this_->trans, this_->trans_cursor); 601 transform_copy(this_->trans, this_->trans_cursor);
571 l=this_->vehicles; 602 l = this_->vehicles;
572 while (l) 603 while (l)
573 { 604 {
574 nv=l->data; 605 nv = l->data;
575 //dbg(0,"* here *\n"); 606 ////DBG dbg(0,"* here *\n");
576 //dbg(0,"vehicle_draw_004\n"); 607 ////DBG dbg(0,"vehicle_draw_004\n");
577 navit_vehicle_draw(this_, nv, NULL); 608 navit_vehicle_draw(this_, nv, NULL);
578 l=g_list_next(l); 609 l = g_list_next(l);
579 } 610 }
580} 611}
581 612
582static void
583navit_scale(struct navit *this_, long scale, struct point *p, int draw) 613static void navit_scale(struct navit *this_, long scale, struct point *p, int draw)
584{ 614{
585 //dbg(0,"EEnter\n"); 615 //DBG dbg(0,"EEnter\n");
586 struct coord c1, c2, *center; 616 struct coord c1, c2, *center;
587 617
588 if (scale < this_->zoom_min) 618 if (scale < this_->zoom_min)
589 { 619 {
590 scale=this_->zoom_min; 620 scale = this_->zoom_min;
591 } 621 }
592 622
593 if (scale > this_->zoom_max) 623 if (scale > this_->zoom_max)
594 { 624 {
595 scale=this_->zoom_max; 625 scale = this_->zoom_max;
596 } 626 }
597 627
598 // return scale value to android 628 // return scale value to android
599#ifdef HAVE_API_ANDROID 629#ifdef HAVE_API_ANDROID
600 android_return_generic_int(3, (int)scale); 630 android_return_generic_int(3, (int)scale);
613 center = transform_center(this_->trans); 643 center = transform_center(this_->trans);
614 center->x += c1.x - c2.x; 644 center->x += c1.x - c2.x;
615 center->y += c1.y - c2.y; 645 center->y += c1.y - c2.y;
616 } 646 }
617 647
648 //DBG dbg(0,"aa331\n");
649
618 if (draw) 650 if (draw)
619 { 651 {
620 navit_draw(this_); 652 navit_draw(this_);
621 } 653 }
654
655 //DBG dbg(0,"leave\n");
622} 656}
623 657
624/** 658/**
625 * @brief Automatically adjusts zoom level 659 * @brief Automatically adjusts zoom level
626 * 660 *
630 * @param this_ The navit struct 664 * @param this_ The navit struct
631 * @param center The "immovable" point - i.e. the vehicles position if we're centering on the vehicle 665 * @param center The "immovable" point - i.e. the vehicles position if we're centering on the vehicle
632 * @param speed The vehicles speed in meters per second 666 * @param speed The vehicles speed in meters per second
633 * @param dir The direction into which the vehicle moves 667 * @param dir The direction into which the vehicle moves
634 */ 668 */
635static void
636navit_autozoom(struct navit *this_, struct coord *center, int speed, int draw) 669static void navit_autozoom(struct navit *this_, struct coord *center, int speed, int draw)
637{ 670{
638 struct point pc; 671 struct point pc;
639 int distance,w,h; 672 int distance, w, h;
640 double new_scale; 673 double new_scale;
641 long scale; 674 long scale;
642 675
643 if (! this_->autozoom_active) { 676 if (!this_->autozoom_active)
677 {
644 return; 678 return;
645 } 679 }
646 680
647 distance = speed * this_->autozoom_secs; 681 distance = speed * this_->autozoom_secs;
648 682
652 686
653 /* We make sure that the point we want to see is within a certain range 687 /* We make sure that the point we want to see is within a certain range
654 * around the vehicle. The radius of this circle is the size of the 688 * around the vehicle. The radius of this circle is the size of the
655 * screen. This doesn't necessarily mean the point is visible because of 689 * screen. This doesn't necessarily mean the point is visible because of
656 * perspective etc. Quite rough, but should be enough. */ 690 * perspective etc. Quite rough, but should be enough. */
657 691
658 if (w > h) { 692 if (w > h)
693 {
659 new_scale = (double)distance / h * 16; 694 new_scale = (double) distance / h * 16;
660 } else { 695 }
696 else
697 {
661 new_scale = (double)distance / w * 16; 698 new_scale = (double) distance / w * 16;
662 } 699 }
663 700
664 if (abs(new_scale - scale) < 2) { 701 if (abs(new_scale - scale) < 2)
702 {
665 return; // Smoothing 703 return; // Smoothing
666 } 704 }
667 705
668 if (new_scale >= this_->autozoom_min) { 706 if (new_scale >= this_->autozoom_min)
707 {
669 navit_scale(this_, (long)new_scale, &pc, 0); 708 navit_scale(this_, (long) new_scale, &pc, 0);
670 } else { 709 }
710 else
711 {
671 if (scale != this_->autozoom_min) { 712 if (scale != this_->autozoom_min)
713 {
672 navit_scale(this_, this_->autozoom_min, &pc, 0); 714 navit_scale(this_, this_->autozoom_min, &pc, 0);
673 } 715 }
674 } 716 }
675} 717}
676 718
680 * @param navit The navit instance 722 * @param navit The navit instance
681 * @param factor The zoom factor, usually 2 723 * @param factor The zoom factor, usually 2
682 * @param p The invariant point (if set to NULL, default to center) 724 * @param p The invariant point (if set to NULL, default to center)
683 * @returns nothing 725 * @returns nothing
684 */ 726 */
685void
686navit_zoom_in(struct navit *this_, int factor, struct point *p) 727void navit_zoom_in(struct navit *this_, int factor, struct point *p)
687{ 728{
688 //dbg(0,"EEnter\n"); 729 ////DBG dbg(0,"EEnter\n");
689 long scale=transform_get_scale(this_->trans)/factor; 730 long scale = transform_get_scale(this_->trans) / factor;
690 if (scale < 1) 731 if (scale < 1)
691 scale=1; 732 scale = 1;
692 //dbg(0,"zoom in -> scale=%d",scale); 733 ////DBG dbg(0,"zoom in -> scale=%d",scale);
693 navit_scale(this_, scale, p, 1); 734 navit_scale(this_, scale, p, 1);
694} 735}
695 736
696/** 737/**
697 * Change the current zoom level 738 * Change the current zoom level
699 * @param navit The navit instance 740 * @param navit The navit instance
700 * @param factor The zoom factor, usually 2 741 * @param factor The zoom factor, usually 2
701 * @param p The invariant point (if set to NULL, default to center) 742 * @param p The invariant point (if set to NULL, default to center)
702 * @returns nothing 743 * @returns nothing
703 */ 744 */
704void
705navit_zoom_out(struct navit *this_, int factor, struct point *p) 745void navit_zoom_out(struct navit *this_, int factor, struct point *p)
706{ 746{
707 //dbg(0,"EEnter\n"); 747 ////DBG dbg(0,"EEnter\n");
708 long scale=transform_get_scale(this_->trans)*factor; 748 long scale = transform_get_scale(this_->trans) * factor;
709 //dbg(0,"zoom out -> scale=%d",scale); 749 ////DBG dbg(0,"zoom out -> scale=%d",scale);
710 navit_scale(this_, scale, p, 1); 750 navit_scale(this_, scale, p, 1);
711} 751}
712 752
713int
714navit_get_cur_pnt(struct navit *this_, struct point *p) 753int navit_get_cur_pnt(struct navit *this_, struct point *p)
715{ 754{
716 //dbg(0,"EEnter\n"); 755 ////DBG dbg(0,"EEnter\n");
717 return navit_get_cursor_pnt(this_, p, 0, NULL); 756 return navit_get_cursor_pnt(this_, p, 0, NULL);
718} 757}
719 758
720void
721navit_zoom_in_cursor(struct navit *this_, int factor) 759void navit_zoom_in_cursor(struct navit *this_, int factor)
722{ 760{
723 //dbg(0,"EEnter\n"); 761 ////DBG dbg(0,"EEnter\n");
724 struct point p; 762 struct point p;
725 if (this_->vehicle && this_->vehicle->follow_curr <= 1 && navit_get_cursor_pnt(this_, &p, 0, NULL)) { 763 if (this_->vehicle && this_->vehicle->follow_curr <= 1 && navit_get_cursor_pnt(this_, &p, 0, NULL))
764 {
726 navit_zoom_in(this_, factor, &p); 765 navit_zoom_in(this_, factor, &p);
727 this_->vehicle->follow_curr=this_->vehicle->follow; 766 this_->vehicle->follow_curr = this_->vehicle->follow;
767 }
728 } else 768 else
729 navit_zoom_in(this_, factor, NULL); 769 navit_zoom_in(this_, factor, NULL);
730} 770}
731 771
732void
733navit_zoom_to_scale(struct navit *this_, int new_scale) 772void navit_zoom_to_scale(struct navit *this_, int new_scale)
734{ 773{
735 //dbg(0,"EEnter\n"); 774 //DBG dbg(0,"EEnter\n");
736 long scale=transform_get_scale(this_->trans); 775 long scale = transform_get_scale(this_->trans);
737 long new_scale_long=new_scale; 776 long new_scale_long = new_scale;
738 //dbg(0,"zoom to scale -> old scale=%d",scale); 777 //DBG dbg(0,"zoom to scale -> old scale=%d",scale);
739 //dbg(0,"zoom to scale -> want scale=%d",new_scale_long); 778 //DBG dbg(0,"zoom to scale -> want scale=%d",new_scale_long);
740 779
741 // only do something if scale changed! 780 // only do something if scale changed!
742 if (scale != new_scale_long) 781 if (scale != new_scale_long)
743 { 782 {
744 navit_scale(this_, new_scale_long, NULL, 1); 783 navit_scale(this_, new_scale_long, NULL, 1);
745 } 784 }
746} 785}
747 786
748void
749navit_zoom_out_cursor(struct navit *this_, int factor) 787void navit_zoom_out_cursor(struct navit *this_, int factor)
750{ 788{
751 //dbg(0,"EEnter\n"); 789 ////DBG dbg(0,"EEnter\n");
752 struct point p; 790 struct point p;
753 if (this_->vehicle && this_->vehicle->follow_curr <= 1 && navit_get_cursor_pnt(this_, &p, 0, NULL)) { 791 if (this_->vehicle && this_->vehicle->follow_curr <= 1 && navit_get_cursor_pnt(this_, &p, 0, NULL))
792 {
754 navit_zoom_out(this_, 2, &p); 793 navit_zoom_out(this_, 2, &p);
755 this_->vehicle->follow_curr=this_->vehicle->follow; 794 this_->vehicle->follow_curr = this_->vehicle->follow;
795 }
756 } else 796 else
757 navit_zoom_out(this_, 2, NULL); 797 navit_zoom_out(this_, 2, NULL);
758} 798}
759 799
760static int
761navit_cmd_zoom_in(struct navit *this_) 800static int navit_cmd_zoom_in(struct navit *this_)
762{ 801{
763 //dbg(0,"EEnter\n"); 802 ////DBG dbg(0,"EEnter\n");
764 navit_zoom_in_cursor(this_, 2); 803 navit_zoom_in_cursor(this_, 2);
765 return 0; 804 return 0;
766} 805}
767 806
768static int
769navit_cmd_zoom_out(struct navit *this_) 807static int navit_cmd_zoom_out(struct navit *this_)
770{ 808{
771 //dbg(0,"EEnter\n"); 809 ////DBG dbg(0,"EEnter\n");
772 navit_zoom_out_cursor(this_, 2); 810 navit_zoom_out_cursor(this_, 2);
773 return 0; 811 return 0;
774} 812}
775 813
776
777static void
778navit_cmd_say(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 814static void navit_cmd_say(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
779{ 815{
780 //dbg(0,"EEnter\n"); 816 ////DBG dbg(0,"EEnter\n");
781 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) 817 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str)
818 {
782 navit_say(this, in[0]->u.str); 819 navit_say(this, in[0]->u.str);
820 }
783} 821}
784 822
785static GHashTable *cmd_int_var_hash = NULL; 823static GHashTable *cmd_int_var_hash = NULL;
786static GHashTable *cmd_attr_var_hash = NULL; 824static GHashTable *cmd_attr_var_hash = NULL;
787 825
793 * @param in input attributes in[0] is the key string, in[1] is the integer value to store 831 * @param in input attributes in[0] is the key string, in[1] is the integer value to store
794 * @param out output attributes, unused 832 * @param out output attributes, unused
795 * @param valid unused 833 * @param valid unused
796 * @returns nothing 834 * @returns nothing
797 */ 835 */
798static void
799navit_cmd_set_int_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 836static void navit_cmd_set_int_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
800{ 837{
801 //dbg(0,"EEnter\n"); 838 ////DBG dbg(0,"EEnter\n");
802 char*key; 839 char*key;
803 struct attr*val; 840 struct attr*val;
804 if(!cmd_int_var_hash) { 841 if (!cmd_int_var_hash)
842 {
805 cmd_int_var_hash = g_hash_table_new(g_str_hash, g_str_equal); 843 cmd_int_var_hash = g_hash_table_new(g_str_hash, g_str_equal);
806 } 844 }
807 845
808 if ( (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) && 846 if ((in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) && (in && in[1] && ATTR_IS_NUMERIC(in[1]->type)))
809 (in && in[1] && ATTR_IS_NUMERIC(in[1]->type))) { 847 {
810 val = g_new(struct attr,1); 848 val = g_new(struct attr,1);
811 attr_dup_content(in[1],val); 849 attr_dup_content(in[1], val);
812 key = g_strdup(in[0]->u.str); 850 key = g_strdup(in[0]->u.str);
813 g_hash_table_insert(cmd_int_var_hash, key, val); 851 g_hash_table_insert(cmd_int_var_hash, key, val);
814 } 852 }
815} 853}
816
817 854
818/** 855/**
819 * Store key value pair for the command system (for attr typed values, can be used as opaque handles) 856 * Store key value pair for the command system (for attr typed values, can be used as opaque handles)
820 * 857 *
821 * @param navit The navit instance 858 * @param navit The navit instance
824 * @param out output attributes, unused 861 * @param out output attributes, unused
825 * @param valid unused 862 * @param valid unused
826 * @returns nothing 863 * @returns nothing
827 */ 864 */
828//TODO free stored attributes on navit_destroy 865//TODO free stored attributes on navit_destroy
829static void
830navit_cmd_set_attr_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 866static void navit_cmd_set_attr_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
831{ 867{
832 //dbg(0,"EEnter\n"); 868 ////DBG dbg(0,"EEnter\n");
833 char*key; 869 char*key;
834 struct attr*val; 870 struct attr*val;
835 if(!cmd_attr_var_hash) { 871 if (!cmd_attr_var_hash)
872 {
836 cmd_attr_var_hash = g_hash_table_new(g_str_hash, g_str_equal); 873 cmd_attr_var_hash = g_hash_table_new(g_str_hash, g_str_equal);
837 } 874 }
838 875
839 if ( (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) && 876 if ((in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) && (in && in[1]))
840 (in && in[1] )) { 877 {
841 val = attr_dup(in[1]); 878 val = attr_dup(in[1]);
842 //val = in[1]; 879 //val = in[1];
843 key = g_strdup(in[0]->u.str); 880 key = g_strdup(in[0]->u.str);
844 g_hash_table_insert(cmd_attr_var_hash, key, val); 881 g_hash_table_insert(cmd_attr_var_hash, key, val);
845 } 882 }
846} 883}
847
848
849 884
850/** 885/**
851 * command to toggle the active state of a named layer of the current layout 886 * command to toggle the active state of a named layer of the current layout
852 * 887 *
853 * @param navit The navit instance 888 * @param navit The navit instance
855 * @param in input attribute in[0] is the name of the layer 890 * @param in input attribute in[0] is the name of the layer
856 * @param out output unused 891 * @param out output unused
857 * @param valid unused 892 * @param valid unused
858 * @returns nothing 893 * @returns nothing
859 */ 894 */
860static void
861navit_cmd_toggle_layer(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 895static void navit_cmd_toggle_layer(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
862{ 896{
863 //dbg(0,"EEnter\n"); 897 ////DBG dbg(0,"EEnter\n");
864 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) { 898 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str)
899 {
865 if(this->layout_current && this->layout_current->layers) { 900 if (this->layout_current && this->layout_current->layers)
901 {
866 GList* layers = this->layout_current->layers; 902 GList* layers = this->layout_current->layers;
867 while (layers) { 903 while (layers)
904 {
868 struct layer*l=layers->data; 905 struct layer*l = layers->data;
869 if(l && !strcmp(l->name,in[0]->u.str) ) { 906 if (l && !strcmp(l->name, in[0]->u.str))
907 {
870 l->active ^= 1; 908 l->active ^= 1;
871 navit_draw(this); 909 navit_draw(this);
872 return; 910 return;
873 } 911 }
874 layers=g_list_next(layers); 912 layers = g_list_next(layers);
875 }
876 } 913 }
877 } 914 }
915 }
878} 916}
879 917
880/** 918/**
881 * adds an item with the current coordinate of the vehicle to a named map 919 * adds an item with the current coordinate of the vehicle to a named map
882 * 920 *
885 * @param in input attribute in[0] is the name of the map 923 * @param in input attribute in[0] is the name of the map
886 * @param out output attribute, 0 on error or the id of the created item on success 924 * @param out output attribute, 0 on error or the id of the created item on success
887 * @param valid unused 925 * @param valid unused
888 * @returns nothing 926 * @returns nothing
889 */ 927 */
890static void
891navit_cmd_map_add_curr_pos(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 928static void navit_cmd_map_add_curr_pos(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
892{ 929{
893 //dbg(0,"EEnter\n"); 930 ////DBG dbg(0,"EEnter\n");
894 struct attr **list = g_new0(struct attr *,2); 931 struct attr **list = g_new0(struct attr *,2);
895 struct attr*val = g_new0(struct attr,1); 932 struct attr*val = g_new0(struct attr,1);
896 struct mapset* ms; 933 struct mapset* ms;
897 struct map_selection sel; 934 struct map_selection sel;
898 const int selection_range = 10; 935 const int selection_range = 10;
900 struct item *it; 937 struct item *it;
901 struct map* curr_map = NULL; 938 struct map* curr_map = NULL;
902 struct coord curr_coord; 939 struct coord curr_coord;
903 struct map_rect *mr; 940 struct map_rect *mr;
904 941
905 val->type = attr_type_item_begin; 942 val->type = attr_type_item_begin;
906 val->u.item = NULL; //return invalid item on error 943 val->u.item = NULL; //return invalid item on error
907 list[0] = val; 944 list[0] = val;
908 list[1] = NULL; 945 list[1] = NULL;
909 *out = list; 946 *out = list;
910 if (
911 in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str && //map name 947 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str && //map name
912 in[1] && ATTR_IS_STRING(in[1]->type) && in[1]->u.str //item type 948 in[1] && ATTR_IS_STRING(in[1]->type) && in[1]->u.str //item type
913 ) { 949 )
950 {
914 951
915 if(!(ms=navit_get_mapset(this))) { 952 if (!(ms = navit_get_mapset(this)))
953 {
916 return; 954 return;
917 } 955 }
918 956
919 if((item_type = item_from_name(in[1]->u.str))==type_none) { 957 if ((item_type = item_from_name(in[1]->u.str)) == type_none)
958 {
920 return; 959 return;
921 } 960 }
922 961
923 curr_map = mapset_get_map_by_name(ms, in[0]->u.str); 962 curr_map = mapset_get_map_by_name(ms, in[0]->u.str);
924 963
925 //no map with the given name found 964 //no map with the given name found
926 if( ! curr_map) { 965 if (!curr_map)
966 {
927 return; 967 return;
928 } 968 }
929 969
930 if(this->vehicle && this->vehicle->vehicle ) { 970 if (this->vehicle && this->vehicle->vehicle)
971 {
931 struct attr pos_attr; 972 struct attr pos_attr;
932 if(vehicle_get_attr(this->vehicle->vehicle,attr_position_coord_geo,&pos_attr,NULL)) { 973 if (vehicle_get_attr(this->vehicle->vehicle, attr_position_coord_geo, &pos_attr, NULL))
974 {
933 transform_from_geo(projection_mg, pos_attr.u.coord_geo, &curr_coord); 975 transform_from_geo(projection_mg, pos_attr.u.coord_geo, &curr_coord);
976 }
934 } else { 977 else
978 {
935 return; 979 return;
936 } 980 }
981 }
937 } else { 982 else
983 {
938 return; 984 return;
939 } 985 }
940 986
941 sel.next=NULL; 987 sel.next = NULL;
942 sel.order=18; 988 sel.order = 18;
943 sel.range.min=type_none; 989 sel.range.min = type_none;
944 sel.range.max=type_tec_common; 990 sel.range.max = type_tec_common;
945 sel.u.c_rect.lu.x=curr_coord.x-selection_range; 991 sel.u.c_rect.lu.x = curr_coord.x - selection_range;
946 sel.u.c_rect.lu.y=curr_coord.y+selection_range; 992 sel.u.c_rect.lu.y = curr_coord.y + selection_range;
947 sel.u.c_rect.rl.x=curr_coord.x+selection_range; 993 sel.u.c_rect.rl.x = curr_coord.x + selection_range;
948 sel.u.c_rect.rl.y=curr_coord.y-selection_range; 994 sel.u.c_rect.rl.y = curr_coord.y - selection_range;
949 995
950 mr = map_rect_new(curr_map, &sel); 996 mr = map_rect_new(curr_map, &sel);
951 if(mr) { 997 if (mr)
998 {
952 it = map_rect_create_item( mr, item_type); 999 it = map_rect_create_item(mr, item_type);
953 item_coord_set(it,&curr_coord, 1, change_mode_modify); 1000 item_coord_set(it, &curr_coord, 1, change_mode_modify);
954 val->u.item = it; 1001 val->u.item = it;
955 } 1002 }
956 map_rect_destroy(mr); 1003 map_rect_destroy(mr);
957 } 1004 }
958} 1005}
959 1006
960/** 1007/**
961 * sets an attribute (name value pair) of a map item specified by map name and item id 1008 * sets an attribute (name value pair) of a map item specified by map name and item id
962 * 1009 *
965 * @param in input attribute in[0] - name of the map ; in[1] - item ; in[2] - attr name ; in[3] - attr value 1012 * @param in input attribute in[0] - name of the map ; in[1] - item ; in[2] - attr name ; in[3] - attr value
966 * @param out output attribute, 0 on error, 1 on success 1013 * @param out output attribute, 0 on error, 1 on success
967 * @param valid unused 1014 * @param valid unused
968 * @returns nothing 1015 * @returns nothing
969 */ 1016 */
970static void
971navit_cmd_map_item_set_attr(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1017static void navit_cmd_map_item_set_attr(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
972{ 1018{
973 //dbg(0,"EEnter\n"); 1019 ////DBG dbg(0,"EEnter\n");
974 if (
975 in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str &&//map name 1020 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str && //map name
976 in[1] && ATTR_IS_ITEM(in[1]->type) && //item 1021 in[1] && ATTR_IS_ITEM(in[1]->type) && //item
977 in[2] && ATTR_IS_STRING(in[2]->type) && in[2]->u.str && //attr_type str 1022 in[2] && ATTR_IS_STRING(in[2]->type) && in[2]->u.str && //attr_type str
978 in[3] && ATTR_IS_STRING(in[3]->type) && in[3]->u.str //attr_value str 1023 in[3] && ATTR_IS_STRING(in[3]->type) && in[3]->u.str //attr_value str
979 ) { 1024 )
1025 {
980 struct attr attr_to_set; 1026 struct attr attr_to_set;
981 struct map* curr_map = NULL; 1027 struct map* curr_map = NULL;
982 struct mapset *ms; 1028 struct mapset *ms;
983 struct map_selection sel; 1029 struct map_selection sel;
984 const int selection_range = 500; 1030 const int selection_range = 500;
985 struct coord curr_coord; 1031 struct coord curr_coord;
986 struct item *it; 1032 struct item *it;
987 1033
988 if(ATTR_IS_STRING(attr_from_name(in[2]->u.str))) { 1034 if (ATTR_IS_STRING(attr_from_name(in[2]->u.str)))
1035 {
989 attr_to_set.u.str = in[3]->u.str; 1036 attr_to_set.u.str = in[3]->u.str;
990 attr_to_set.type = attr_from_name(in[2]->u.str); 1037 attr_to_set.type = attr_from_name(in[2]->u.str);
991 } 1038 }
992 else if(ATTR_IS_INT(attr_from_name(in[2]->u.str))) { 1039 else if (ATTR_IS_INT(attr_from_name(in[2]->u.str)))
1040 {
993 attr_to_set.u.num = atoi(in[3]->u.str); 1041 attr_to_set.u.num = atoi(in[3]->u.str);
994 attr_to_set.type = attr_from_name(in[2]->u.str); 1042 attr_to_set.type = attr_from_name(in[2]->u.str);
995 } 1043 }
996 else if(ATTR_IS_DOUBLE(attr_from_name(in[2]->u.str))) { 1044 else if (ATTR_IS_DOUBLE(attr_from_name(in[2]->u.str)))
1045 {
997 double* val = g_new0(double,1); 1046 double* val = g_new0(double,1);
998 *val = atof(in[3]->u.str); 1047 *val = atof(in[3]->u.str);
999 attr_to_set.u.numd = val; 1048 attr_to_set.u.numd = val;
1000 attr_to_set.type = attr_from_name(in[2]->u.str); 1049 attr_to_set.type = attr_from_name(in[2]->u.str);
1001 } 1050 }
1002 1051
1003 ms = navit_get_mapset(this); 1052 ms = navit_get_mapset(this);
1004 1053
1005 curr_map = mapset_get_map_by_name(ms, in[0]->u.str); 1054 curr_map = mapset_get_map_by_name(ms, in[0]->u.str);
1006 1055
1007 if( ! curr_map) { 1056 if (!curr_map)
1057 {
1008 return; 1058 return;
1009 } 1059 }
1010 sel.next=NULL; 1060 sel.next = NULL;
1011 sel.order=18; 1061 sel.order = 18;
1012 sel.range.min=type_none; 1062 sel.range.min = type_none;
1013 sel.range.max=type_tec_common; 1063 sel.range.max = type_tec_common;
1014 sel.u.c_rect.lu.x=curr_coord.x-selection_range; 1064 sel.u.c_rect.lu.x = curr_coord.x - selection_range;
1015 sel.u.c_rect.lu.y=curr_coord.y+selection_range; 1065 sel.u.c_rect.lu.y = curr_coord.y + selection_range;
1016 sel.u.c_rect.rl.x=curr_coord.x+selection_range; 1066 sel.u.c_rect.rl.x = curr_coord.x + selection_range;
1017 sel.u.c_rect.rl.y=curr_coord.y-selection_range; 1067 sel.u.c_rect.rl.y = curr_coord.y - selection_range;
1018 1068
1019 it = in[1]->u.item; 1069 it = in[1]->u.item;
1020 if(it) { 1070 if (it)
1071 {
1021 item_attr_set(it, &attr_to_set, change_mode_modify); 1072 item_attr_set(it, &attr_to_set, change_mode_modify);
1022 } 1073 }
1023 } 1074 }
1024} 1075}
1025 1076
1031 * @param in input attribute in[0] is the key string 1082 * @param in input attribute in[0] is the key string
1032 * @param out output attribute, the attr for the given key string if exists or NULL 1083 * @param out output attribute, the attr for the given key string if exists or NULL
1033 * @param valid unused 1084 * @param valid unused
1034 * @returns nothing 1085 * @returns nothing
1035 */ 1086 */
1036static void
1037navit_cmd_get_attr_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1087static void navit_cmd_get_attr_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1038{ 1088{
1039 //dbg(0,"EEnter\n"); 1089 ////DBG dbg(0,"EEnter\n");
1040 struct attr **list = g_new0(struct attr *,2); 1090 struct attr **list = g_new0(struct attr *,2);
1041 if(!cmd_int_var_hash) { 1091 if (!cmd_int_var_hash)
1092 {
1042 struct attr*val = g_new0(struct attr,1); 1093 struct attr*val = g_new0(struct attr,1);
1043 val->type = attr_type_item_begin; 1094 val->type = attr_type_item_begin;
1044 val->u.item = NULL; 1095 val->u.item = NULL;
1045 list[0] = val; 1096 list[0] = val;
1046 } 1097 }
1047 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) { 1098 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str)
1099 {
1048 struct attr*ret = g_hash_table_lookup(cmd_attr_var_hash, in[0]->u.str); 1100 struct attr*ret = g_hash_table_lookup(cmd_attr_var_hash, in[0]->u.str);
1049 if(ret) { 1101 if (ret)
1102 {
1050 list[0] = attr_dup(ret); 1103 list[0] = attr_dup(ret);
1051 } 1104 }
1052 else { 1105 else
1106 {
1053 struct attr*val = g_new0(struct attr,1); 1107 struct attr*val = g_new0(struct attr,1);
1054 val->type = attr_type_int_begin; 1108 val->type = attr_type_int_begin;
1055 val->u.item = NULL; 1109 val->u.item = NULL;
1056 list[0] = val; 1110 list[0] = val;
1111 }
1057 } 1112 }
1058 }
1059 list[1] = NULL; 1113 list[1] = NULL;
1060 *out = list; 1114 *out = list;
1061} 1115}
1062
1063 1116
1064/** 1117/**
1065 * Get value given a key string for the command system 1118 * Get value given a key string for the command system
1066 * 1119 *
1067 * @param navit The navit instance 1120 * @param navit The navit instance
1069 * @param in input attribute in[0] is the key string 1122 * @param in input attribute in[0] is the key string
1070 * @param out output attribute, the value for the given key string if exists or 0 1123 * @param out output attribute, the value for the given key string if exists or 0
1071 * @param valid unused 1124 * @param valid unused
1072 * @returns nothing 1125 * @returns nothing
1073 */ 1126 */
1074static void
1075navit_cmd_get_int_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1127static void navit_cmd_get_int_var(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1076{ 1128{
1077 //dbg(0,"EEnter\n"); 1129 ////DBG dbg(0,"EEnter\n");
1078 struct attr **list = g_new0(struct attr *,2); 1130 struct attr **list = g_new0(struct attr *,2);
1079 if(!cmd_int_var_hash) { 1131 if (!cmd_int_var_hash)
1132 {
1080 struct attr*val = g_new0(struct attr,1); 1133 struct attr*val = g_new0(struct attr,1);
1081 val->type = attr_type_int_begin; 1134 val->type = attr_type_int_begin;
1082 val->u.num = 0; 1135 val->u.num = 0;
1083 list[0] = val; 1136 list[0] = val;
1084 } 1137 }
1085 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str) { 1138 if (in && in[0] && ATTR_IS_STRING(in[0]->type) && in[0]->u.str)
1139 {
1086 struct attr*ret = g_hash_table_lookup(cmd_int_var_hash, in[0]->u.str); 1140 struct attr*ret = g_hash_table_lookup(cmd_int_var_hash, in[0]->u.str);
1087 if(ret) { 1141 if (ret)
1142 {
1088 list[0] = ret; 1143 list[0] = ret;
1089 } 1144 }
1090 else { 1145 else
1146 {
1091 struct attr*val = g_new0(struct attr,1); 1147 struct attr*val = g_new0(struct attr,1);
1092 val->type = attr_type_int_begin; 1148 val->type = attr_type_int_begin;
1093 val->u.num = 0; 1149 val->u.num = 0;
1094 list[0] = val; 1150 list[0] = val;
1151 }
1095 } 1152 }
1096 }
1097 list[1] = NULL; 1153 list[1] = NULL;
1098 *out = list; 1154 *out = list;
1099} 1155}
1100 1156
1101GList *cmd_int_var_stack = NULL; 1157GList *cmd_int_var_stack = NULL;
1108 * @param in input attribute in[0] is the integer attibute to push 1164 * @param in input attribute in[0] is the integer attibute to push
1109 * @param out output attributes, unused 1165 * @param out output attributes, unused
1110 * @param valid unused 1166 * @param valid unused
1111 * @returns nothing 1167 * @returns nothing
1112 */ 1168 */
1113static void
1114navit_cmd_push_int(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1169static void navit_cmd_push_int(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1115{ 1170{
1116 //dbg(0,"EEnter\n"); 1171 ////DBG dbg(0,"EEnter\n");
1117 if (in && in[0] && ATTR_IS_NUMERIC(in[0]->type)) { 1172 if (in && in[0] && ATTR_IS_NUMERIC(in[0]->type))
1173 {
1118 struct attr*val = g_new(struct attr,1); 1174 struct attr*val = g_new(struct attr,1);
1119 attr_dup_content(in[0],val); 1175 attr_dup_content(in[0], val);
1120 cmd_int_var_stack = g_list_prepend(cmd_int_var_stack, val); 1176 cmd_int_var_stack = g_list_prepend(cmd_int_var_stack, val);
1121 } 1177 }
1122} 1178}
1123 1179
1124/** 1180/**
1129 * @param in input attributes unused 1185 * @param in input attributes unused
1130 * @param out output attribute, the value popped if stack isn't empty or 0 1186 * @param out output attribute, the value popped if stack isn't empty or 0
1131 * @param valid unused 1187 * @param valid unused
1132 * @returns nothing 1188 * @returns nothing
1133 */ 1189 */
1134static void
1135navit_cmd_pop_int(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1190static void navit_cmd_pop_int(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1136{ 1191{
1137 //dbg(0,"EEnter\n"); 1192 ////DBG dbg(0,"EEnter\n");
1138 struct attr **list = g_new0(struct attr *,2); 1193 struct attr **list = g_new0(struct attr *,2);
1139 if(!cmd_int_var_stack) { 1194 if (!cmd_int_var_stack)
1195 {
1140 struct attr*val = g_new0(struct attr,1); 1196 struct attr*val = g_new0(struct attr,1);
1141 val->type = attr_type_int_begin; 1197 val->type = attr_type_int_begin;
1142 val->u.num = 0; 1198 val->u.num = 0;
1143 list[0] = val; 1199 list[0] = val;
1144 } 1200 }
1145 else { 1201 else
1202 {
1146 list[0] = cmd_int_var_stack->data; 1203 list[0] = cmd_int_var_stack->data;
1147 cmd_int_var_stack = g_list_remove_link(cmd_int_var_stack,cmd_int_var_stack); 1204 cmd_int_var_stack = g_list_remove_link(cmd_int_var_stack, cmd_int_var_stack);
1148 } 1205 }
1149 list[1] = NULL; 1206 list[1] = NULL;
1150 *out = list; 1207 *out = list;
1151} 1208}
1152 1209
1158 * @param in input attributes unused 1215 * @param in input attributes unused
1159 * @param out output attribute, the size of stack 1216 * @param out output attribute, the size of stack
1160 * @param valid unused 1217 * @param valid unused
1161 * @returns nothing 1218 * @returns nothing
1162 */ 1219 */
1163static void
1164navit_cmd_int_stack_size(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1220static void navit_cmd_int_stack_size(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1165{ 1221{
1166 //dbg(0,"EEnter\n"); 1222 ////DBG dbg(0,"EEnter\n");
1167 struct attr **list; 1223 struct attr **list;
1168 struct attr *attr = g_new0(struct attr ,1); 1224 struct attr *attr = g_new0(struct attr ,1);
1169 attr->type = attr_type_int_begin; 1225 attr->type = attr_type_int_begin;
1170 if(!cmd_int_var_stack) { 1226 if (!cmd_int_var_stack)
1227 {
1171 attr->u.num = 0; 1228 attr->u.num = 0;
1172 } 1229 }
1173 else { 1230 else
1231 {
1174 attr->u.num = g_list_length(cmd_int_var_stack); 1232 attr->u.num = g_list_length(cmd_int_var_stack);
1175 }
1176 list = g_new0(struct attr *,2); 1233 }list = g_new0(struct attr *,2);
1177 list[0] = attr; 1234 list[0] = attr;
1178 list[1] = NULL; 1235 list[1] = NULL;
1179 *out = list; 1236 *out = list;
1180 cmd_int_var_stack = g_list_remove_link(cmd_int_var_stack,cmd_int_var_stack); 1237 cmd_int_var_stack = g_list_remove_link(cmd_int_var_stack, cmd_int_var_stack);
1181} 1238}
1182 1239
1183static void
1184navit_cmd_set_destination(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1240static void navit_cmd_set_destination(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1185{ 1241{
1186 //dbg(0,"EEnter\n"); 1242 ////DBG dbg(0,"EEnter\n");
1187 struct pcoord pc; 1243 struct pcoord pc;
1188 char *description=NULL; 1244 char *description = NULL;
1189 if (!in) 1245 if (!in)
1190 return; 1246 return;
1191 if (!in[0]) 1247 if (!in[0])
1192 return; 1248 return;
1193 pc.pro = transform_get_projection(this->trans); 1249 pc.pro = transform_get_projection(this->trans);
1194 if (ATTR_IS_COORD(in[0]->type)) { 1250 if (ATTR_IS_COORD(in[0]->type))
1251 {
1195 pc.x=in[0]->u.coord->x; 1252 pc.x = in[0]->u.coord->x;
1196 pc.y=in[0]->u.coord->y; 1253 pc.y = in[0]->u.coord->y;
1197 in++; 1254 in++;
1255 }
1198 } else if (ATTR_IS_PCOORD(in[0]->type)) { 1256 else if (ATTR_IS_PCOORD(in[0]->type))
1257 {
1199 pc=*in[0]->u.pcoord; 1258 pc = *in[0]->u.pcoord;
1200 in++; 1259 in++;
1260 }
1201 } else if (in[1] && in[2] && ATTR_IS_INT(in[0]->type) && ATTR_IS_INT(in[1]->type) && ATTR_IS_INT(in[2]->type)) { 1261 else if (in[1] && in[2] && ATTR_IS_INT(in[0]->type) && ATTR_IS_INT(in[1]->type) && ATTR_IS_INT(in[2]->type))
1262 {
1202 pc.pro=in[0]->u.num; 1263 pc.pro = in[0]->u.num;
1203 pc.x=in[1]->u.num; 1264 pc.x = in[1]->u.num;
1204 pc.y=in[2]->u.num; 1265 pc.y = in[2]->u.num;
1205 in+=3; 1266 in += 3;
1267 }
1206 } else if (in[1] && ATTR_IS_INT(in[0]->type) && ATTR_IS_INT(in[1]->type)) { 1268 else if (in[1] && ATTR_IS_INT(in[0]->type) && ATTR_IS_INT(in[1]->type))
1269 {
1207 pc.x=in[0]->u.num; 1270 pc.x = in[0]->u.num;
1208 pc.y=in[1]->u.num; 1271 pc.y = in[1]->u.num;
1209 in+=2; 1272 in += 2;
1273 }
1210 } else 1274 else
1275 {
1211 return; 1276 return;
1277 }
1212 if (in[0] && ATTR_IS_STRING(in[0]->type)) 1278 if (in[0] && ATTR_IS_STRING(in[0]->type))
1279 {
1213 description=in[0]->u.str; 1280 description = in[0]->u.str;
1281 }
1214 navit_set_destination(this, &pc, description, 1); 1282 navit_set_destination(this, &pc, description, 1);
1215} 1283}
1216 1284
1217static void
1218navit_cmd_fmt_coordinates(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1285static void navit_cmd_fmt_coordinates(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1219{ 1286{
1220 //dbg(0,"EEnter\n"); 1287 ////DBG dbg(0,"EEnter\n");
1221 struct attr attr; 1288 struct attr attr;
1222 attr.type=attr_type_string_begin; 1289 attr.type = attr_type_string_begin;
1223 attr.u.str="Fix me"; 1290 attr.u.str = "Fix me";
1224 if (out) { 1291 if (out)
1292 {
1225 *out=attr_generic_add_attr(*out, &attr); 1293 *out = attr_generic_add_attr(*out, &attr);
1226 } 1294 }
1227} 1295}
1228 1296
1229/** 1297/**
1230 * Join several string attributes into one 1298 * Join several string attributes into one
1234 * @param in input attributes in[0] - separator, in[1..] - attributes to join 1302 * @param in input attributes in[0] - separator, in[1..] - attributes to join
1235 * @param out output attribute joined attribute as string 1303 * @param out output attribute joined attribute as string
1236 * @param valid unused 1304 * @param valid unused
1237 * @returns nothing 1305 * @returns nothing
1238 */ 1306 */
1239static void
1240navit_cmd_strjoin(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1307static void navit_cmd_strjoin(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1241{ 1308{
1242 //dbg(0,"EEnter\n"); 1309 ////DBG dbg(0,"EEnter\n");
1243 struct attr attr; 1310 struct attr attr;
1244 gchar *ret, *sep; 1311 gchar *ret, *sep;
1245 int i; 1312 int i;
1246 attr.type=attr_type_string_begin; 1313 attr.type = attr_type_string_begin;
1247 attr.u.str=NULL; 1314 attr.u.str = NULL;
1248 if(in[0] && in[1]) { 1315 if (in[0] && in[1])
1316 {
1249 sep=attr_to_text(in[0],NULL,1); 1317 sep = attr_to_text(in[0], NULL, 1);
1250 ret=attr_to_text(in[1],NULL,1); 1318 ret = attr_to_text(in[1], NULL, 1);
1251 for(i=2;in[i];i++) { 1319 for (i = 2; in[i]; i++)
1320 {
1252 gchar *in_i=attr_to_text(in[i],NULL,1); 1321 gchar *in_i = attr_to_text(in[i], NULL, 1);
1253 gchar *r=g_strjoin(sep,ret,in_i,NULL); 1322 gchar *r = g_strjoin(sep, ret, in_i, NULL);
1254 g_free(in_i); 1323 g_free(in_i);
1255 g_free(ret); 1324 g_free(ret);
1256 ret=r; 1325 ret = r;
1257 } 1326 }
1258 g_free(sep); 1327 g_free(sep);
1259 attr.u.str=ret; 1328 attr.u.str = ret;
1260 if(out) { 1329 if (out)
1330 {
1261 *out=attr_generic_add_attr(*out, &attr); 1331 *out = attr_generic_add_attr(*out, &attr);
1262 } 1332 }
1263 g_free(ret); 1333 g_free(ret);
1264 } 1334 }
1265} 1335}
1266 1336
1272 * @param in input attributes in[0] - name of executable, in[1..] - parameters 1342 * @param in input attributes in[0] - name of executable, in[1..] - parameters
1273 * @param out output attribute unused 1343 * @param out output attribute unused
1274 * @param valid unused 1344 * @param valid unused
1275 * @returns nothing 1345 * @returns nothing
1276 */ 1346 */
1277static void
1278navit_cmd_spawn(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid) 1347static void navit_cmd_spawn(struct navit *this, char *function, struct attr **in, struct attr ***out, int *valid)
1279{ 1348{
1280 //dbg(0,"EEnter\n"); 1349 ////DBG dbg(0,"EEnter\n");
1281 int i,j, nparms, nvalid; 1350 int i, j, nparms, nvalid;
1282 const char ** argv=NULL; 1351 const char ** argv = NULL;
1283 struct spawn_process_info *pi; 1352 struct spawn_process_info *pi;
1284 1353
1285 nparms=0; 1354 nparms = 0;
1286 nvalid=0; 1355 nvalid = 0;
1287 if(in) { 1356 if (in)
1357 {
1288 while(in[nparms]) { 1358 while (in[nparms])
1359 {
1289 if (in[nparms]->type!=attr_none) 1360 if (in[nparms]->type != attr_none)
1290 nvalid++; 1361 nvalid++;
1291 nparms++; 1362 nparms++;
1292 } 1363 }
1293 } 1364 }
1294 1365
1295 if(nvalid>0) { 1366 if (nvalid > 0)
1367 {
1296 argv=g_new(char*,nvalid+1); 1368 argv=g_new(char*,nvalid+1);
1297 for(i=0,j=0;in[i];i++) { 1369 for (i = 0, j = 0; in[i]; i++)
1370 {
1298 if(in[i]->type!=attr_none ) { 1371 if (in[i]->type != attr_none)
1372 {
1299 argv[j++]=attr_to_text(in[i],NULL,1); 1373 argv[j++] = attr_to_text(in[i], NULL, 1);
1374 }
1300 } else { 1375 else
1376 {
1301 dbg(0,"Parameter #%i is attr_none - skipping\n",i); 1377 //DBG dbg(0, "Parameter #%i is attr_none - skipping\n", i);
1302 }
1303 } 1378 }
1379 }
1304 argv[j]=NULL; 1380 argv[j] = NULL;
1305 pi=spawn_process(argv); 1381 pi = spawn_process(argv);
1306 1382
1307 // spawn_process() testing suite - uncomment following code to test. 1383 // spawn_process() testing suite - uncomment following code to test.
1308 //sleep(3); 1384 //sleep(3);
1309 // example of non-blocking wait 1385 // example of non-blocking wait
1310 //int st=spawn_process_check_status(pi,0);dbg(0,"status %i\n",st); 1386 //int st=spawn_process_check_status(pi,0);//DBG dbg(0,"status %i\n",st);
1311 // example of blocking wait 1387 // example of blocking wait
1312 //st=spawn_process_check_status(pi,1);dbg(0,"status %i\n",st); 1388 //st=spawn_process_check_status(pi,1);//DBG dbg(0,"status %i\n",st);
1313 // example of wait after process is finished and status is 1389 // example of wait after process is finished and status is
1314 // already tested 1390 // already tested
1315 //st=spawn_process_check_status(pi,1);dbg(0,"status %i\n",st); 1391 //st=spawn_process_check_status(pi,1);//DBG dbg(0,"status %i\n",st);
1316 // example of wait after process is finished and status is 1392 // example of wait after process is finished and status is
1317 // already tested - unblocked 1393 // already tested - unblocked
1318 //st=spawn_process_check_status(pi,0);dbg(0,"status %i\n",st); 1394 //st=spawn_process_check_status(pi,0);//DBG dbg(0,"status %i\n",st);
1319 1395
1320 // End testing suite 1396 // End testing suite
1321 spawn_process_info_free(pi); 1397 spawn_process_info_free(pi);
1322 for(i=0;argv[i];i++) 1398 for (i = 0; argv[i]; i++)
1323 g_free(argv[i]); 1399 g_free(argv[i]);
1324 g_free(argv); 1400 g_free(argv);
1325 } 1401 }
1326} 1402}
1327 1403
1328
1329static struct command_table commands[] = { 1404static struct command_table commands[] =
1405{
1330 {"zoom_in",command_cast(navit_cmd_zoom_in)}, 1406{ "zoom_in", command_cast(navit_cmd_zoom_in) },
1331 {"zoom_out",command_cast(navit_cmd_zoom_out)}, 1407{ "zoom_out", command_cast(navit_cmd_zoom_out) },
1332 {"zoom_to_route",command_cast(navit_cmd_zoom_to_route)}, 1408{ "zoom_to_route", command_cast(navit_cmd_zoom_to_route) },
1333 {"say",command_cast(navit_cmd_say)}, 1409{ "say", command_cast(navit_cmd_say) },
1334 {"set_center_cursor",command_cast(navit_cmd_set_center_cursor)}, 1410{ "set_center_cursor", command_cast(navit_cmd_set_center_cursor) },
1335 {"set_destination",command_cast(navit_cmd_set_destination)}, 1411{ "set_destination", command_cast(navit_cmd_set_destination) },
1336 {"announcer_toggle",command_cast(navit_cmd_announcer_toggle)}, 1412{ "announcer_toggle", command_cast(navit_cmd_announcer_toggle) },
1337 {"fmt_coordinates",command_cast(navit_cmd_fmt_coordinates)}, 1413{ "fmt_coordinates", command_cast(navit_cmd_fmt_coordinates) },
1338 {"set_int_var",command_cast(navit_cmd_set_int_var)}, 1414{ "set_int_var", command_cast(navit_cmd_set_int_var) },
1339 {"get_int_var",command_cast(navit_cmd_get_int_var)}, 1415{ "get_int_var", command_cast(navit_cmd_get_int_var) },
1340 {"push_int",command_cast(navit_cmd_push_int)}, 1416{ "push_int", command_cast(navit_cmd_push_int) },
1341 {"pop_int",command_cast(navit_cmd_pop_int)}, 1417{ "pop_int", command_cast(navit_cmd_pop_int) },
1342 {"int_stack_size",command_cast(navit_cmd_int_stack_size)}, 1418{ "int_stack_size", command_cast(navit_cmd_int_stack_size) },
1343 {"toggle_layer",command_cast(navit_cmd_toggle_layer)}, 1419{ "toggle_layer", command_cast(navit_cmd_toggle_layer) },
1344 {"strjoin",command_cast(navit_cmd_strjoin)}, 1420{ "strjoin", command_cast(navit_cmd_strjoin) },
1345 {"spawn",command_cast(navit_cmd_spawn)}, 1421{ "spawn", command_cast(navit_cmd_spawn) },
1346 {"map_add_curr_pos",command_cast(navit_cmd_map_add_curr_pos)}, 1422{ "map_add_curr_pos", command_cast(navit_cmd_map_add_curr_pos) },
1347 {"map_item_set_attr",command_cast(navit_cmd_map_item_set_attr)}, 1423{ "map_item_set_attr", command_cast(navit_cmd_map_item_set_attr) },
1348 {"set_attr_var",command_cast(navit_cmd_set_attr_var)}, 1424{ "set_attr_var", command_cast(navit_cmd_set_attr_var) },
1349 {"get_attr_var",command_cast(navit_cmd_get_attr_var)}, 1425{ "get_attr_var", command_cast(navit_cmd_get_attr_var) }, };
1350}; 1426
1351
1352void
1353navit_command_add_table(struct navit*this_, struct command_table *commands, int count) 1427void navit_command_add_table(struct navit*this_, struct command_table *commands, int count)
1354{ 1428{
1355 //dbg(0,"EEnter\n"); 1429 ////DBG dbg(0,"EEnter\n");
1356 command_add_table(this_->attr_cbl, commands, count, this_); 1430 command_add_table(this_->attr_cbl, commands, count, this_);
1357} 1431}
1358 1432
1359struct navit * 1433struct navit *
1360navit_new(struct attr *parent, struct attr **attrs) 1434navit_new(struct attr *parent, struct attr **attrs)
1361{ 1435{
1362 //dbg(0,"EEnter\n"); 1436 ////DBG dbg(0,"EEnter\n");
1363 struct navit *this_=g_new0(struct navit, 1); 1437 struct navit *this_=g_new0(struct navit, 1);
1364 struct pcoord center; 1438 struct pcoord center;
1365 struct coord co; 1439 struct coord co;
1366 struct coord_geo g; 1440 struct coord_geo g;
1367 enum projection pro=projection_mg; 1441 enum projection pro = projection_mg;
1368 int zoom = 256; 1442 int zoom = 256;
1369 g.lat=53.13; 1443 g.lat = 53.13;
1370 g.lng=11.70; 1444 g.lng = 11.70;
1371 1445
1372 this_->self.type=attr_navit; 1446 this_->self.type = attr_navit;
1373 this_->self.u.navit=this_; 1447 this_->self.u.navit = this_;
1374 this_->attr_cbl=callback_list_new(); 1448 this_->attr_cbl = callback_list_new();
1375 1449
1376 this_->orientation=-1; 1450 this_->orientation = -1;
1377 this_->tracking_flag=1; 1451 this_->tracking_flag = 1;
1378 this_->recentdest_count=10; 1452 this_->recentdest_count = 10;
1379 this_->osd_configuration=-1; 1453 this_->osd_configuration = -1;
1380 1454
1381 // changed default to 1 1455 // changed default to 1
1382 this_->center_timeout = 1; 1456 this_->center_timeout = 1;
1383 this_->use_mousewheel = 1; 1457 this_->use_mousewheel = 1;
1384 this_->autozoom_secs = 10; 1458 this_->autozoom_secs = 10;
1391 this_->border = 16; 1465 this_->border = 16;
1392 1466
1393 this_->trans = transform_new(); 1467 this_->trans = transform_new();
1394 this_->trans_cursor = transform_new(); 1468 this_->trans_cursor = transform_new();
1395 transform_from_geo(pro, &g, &co); 1469 transform_from_geo(pro, &g, &co);
1396 center.x=co.x; 1470 center.x = co.x;
1397 center.y=co.y; 1471 center.y = co.y;
1398 center.pro = pro; 1472 center.pro = pro;
1399 1473
1400 dbg(0,"setting center from xmlfile [hardcoded]\n"); 1474 //DBG dbg(0, "setting center from xmlfile [hardcoded]\n");
1401 transform_setup(this_->trans, &center, zoom, (this_->orientation != -1) ? this_->orientation : 0); 1475 transform_setup(this_->trans, &center, zoom, (this_->orientation != -1) ? this_->orientation : 0);
1402 1476
1403 // initialze trans_cursor here 1477 // initialze trans_cursor here
1404 transform_copy(this_->trans, this_->trans_cursor); 1478 transform_copy(this_->trans, this_->trans_cursor);
1405 // initialze trans_cursor here 1479 // initialze trans_cursor here
1406 1480
1407 this_->bookmarks=bookmarks_new(&this_->self, NULL, this_->trans); 1481 this_->bookmarks = bookmarks_new(&this_->self, NULL, this_->trans);
1408 1482
1409 this_->prevTs=0; 1483 this_->prevTs = 0;
1410 1484
1411 for (;*attrs; attrs++) { 1485 for (; *attrs; attrs++)
1486 {
1412 navit_set_attr_do(this_, *attrs, 1); 1487 navit_set_attr_do(this_, *attrs, 1);
1413 } 1488 }
1414 this_->displaylist=graphics_displaylist_new(); 1489 this_->displaylist = graphics_displaylist_new();
1415 command_add_table(this_->attr_cbl, commands, sizeof(commands)/sizeof(struct command_table), this_); 1490 command_add_table(this_->attr_cbl, commands, sizeof(commands) / sizeof(struct command_table), this_);
1416 1491
1417 this_->messages = messagelist_new(attrs); 1492 // this_->messages = messagelist_new(attrs);
1418 1493
1419 //dbg(0,"111111\n"); 1494 ////DBG dbg(0,"111111\n");
1420 1495
1421 return this_; 1496 return this_;
1422} 1497}
1423 1498
1424static int
1425navit_set_gui(struct navit *this_, struct gui *gui) 1499static int navit_set_gui(struct navit *this_, struct gui *gui)
1426{ 1500{
1427 //dbg(0,"EEnter\n"); 1501 ////DBG dbg(0,"EEnter\n");
1428 if (this_->gui) 1502 if (this_->gui)
1429 return 0; 1503 return 0;
1430 this_->gui=gui; 1504 this_->gui = gui;
1431 if (gui_has_main_loop(this_->gui)) { 1505 if (gui_has_main_loop(this_->gui))
1506 {
1432 if (! main_loop_gui) { 1507 if (!main_loop_gui)
1508 {
1433 main_loop_gui=this_->gui; 1509 main_loop_gui = this_->gui;
1510 }
1434 } else { 1511 else
1512 {
1435 dbg(0,"gui with main loop already active, ignoring this instance"); 1513 //DBG dbg(0, "gui with main loop already active, ignoring this instance");
1436 return 0; 1514 return 0;
1437 } 1515 }
1438 } 1516 }
1439 return 1; 1517 return 1;
1440} 1518}
1441 1519
1442void
1443navit_add_message(struct navit *this_, char *message) 1520void navit_add_message(struct navit *this_, char *message)
1444{ 1521{
1445 //dbg(0,"EEnter\n"); 1522 ////DBG dbg(0,"EEnter\n");
1446 message_new(this_->messages, message); 1523 // message_new(this_->messages, message);
1447} 1524}
1448 1525
1449struct message
1450*navit_get_messages(struct navit *this_) 1526struct message *navit_get_messages(struct navit *this_)
1451{ 1527{
1452 //dbg(0,"EEnter\n"); 1528 ////DBG dbg(0,"EEnter\n");
1453 return message_get(this_->messages); 1529 // return message_get(this_->messages);
1454} 1530}
1455 1531
1456static int
1457navit_set_graphics(struct navit *this_, struct graphics *gra) 1532static int navit_set_graphics(struct navit *this_, struct graphics *gra)
1458{ 1533{
1459 //dbg(0,"EEnter\n"); 1534 ////DBG dbg(0,"EEnter\n");
1460 if (this_->gra) 1535 if (this_->gra)
1461 return 0; 1536 return 0;
1462 this_->gra=gra; 1537 this_->gra = gra;
1463 this_->resize_callback=callback_new_attr_1(callback_cast(navit_resize), attr_resize, this_); 1538 this_->resize_callback = callback_new_attr_1(callback_cast(navit_resize), attr_resize, this_);
1464 graphics_add_callback(gra, this_->resize_callback); 1539 graphics_add_callback(gra, this_->resize_callback);
1465 this_->button_callback=callback_new_attr_1(callback_cast(navit_button), attr_button, this_); 1540 this_->button_callback = callback_new_attr_1(callback_cast(navit_button), attr_button, this_);
1466 graphics_add_callback(gra, this_->button_callback); 1541 graphics_add_callback(gra, this_->button_callback);
1467 this_->motion_callback=callback_new_attr_1(callback_cast(navit_motion), attr_motion, this_); 1542 this_->motion_callback = callback_new_attr_1(callback_cast(navit_motion), attr_motion, this_);
1468 graphics_add_callback(gra, this_->motion_callback); 1543 graphics_add_callback(gra, this_->motion_callback);
1469 this_->predraw_callback=callback_new_attr_1(callback_cast(navit_predraw), attr_predraw, this_); 1544 this_->predraw_callback = callback_new_attr_1(callback_cast(navit_predraw), attr_predraw, this_);
1470 graphics_add_callback(gra, this_->predraw_callback); 1545 graphics_add_callback(gra, this_->predraw_callback);
1471 //dbg(0,"111111111\n"); 1546 ////DBG dbg(0,"111111111\n");
1472 return 1; 1547 return 1;
1473} 1548}
1474 1549
1475struct graphics * 1550struct graphics *
1476navit_get_graphics(struct navit *this_) 1551navit_get_graphics(struct navit *this_)
1477{ 1552{
1478 //dbg(0,"EEnter\n"); 1553 ////DBG dbg(0,"EEnter\n");
1479 return this_->gra; 1554 return this_->gra;
1480} 1555}
1481 1556
1482struct vehicleprofile * 1557struct vehicleprofile *
1483navit_get_vehicleprofile(struct navit *this_) 1558navit_get_vehicleprofile(struct navit *this_)
1484{ 1559{
1485 //dbg(0,"EEnter\n"); 1560 ////DBG dbg(0,"EEnter\n");
1486 return this_->vehicleprofile; 1561 return this_->vehicleprofile;
1487} 1562}
1488 1563
1489GList * 1564GList *
1490navit_get_vehicleprofiles(struct navit *this_) 1565navit_get_vehicleprofiles(struct navit *this_)
1491{ 1566{
1492 //dbg(0,"EEnter\n"); 1567 ////DBG dbg(0,"EEnter\n");
1493 return this_->vehicleprofiles; 1568 return this_->vehicleprofiles;
1494} 1569}
1495 1570
1496static void
1497navit_projection_set(struct navit *this_, enum projection pro, int draw) 1571static void navit_projection_set(struct navit *this_, enum projection pro, int draw)
1498{ 1572{
1499 //dbg(0,"EEnter\n"); 1573 ////DBG dbg(0,"EEnter\n");
1500 struct coord_geo g; 1574 struct coord_geo g;
1501 struct coord *c; 1575 struct coord *c;
1502 1576
1503 c=transform_center(this_->trans); 1577 c = transform_center(this_->trans);
1504 transform_to_geo(transform_get_projection(this_->trans), c, &g); 1578 transform_to_geo(transform_get_projection(this_->trans), c, &g);
1505 transform_set_projection(this_->trans, pro); 1579 transform_set_projection(this_->trans, pro);
1506 transform_from_geo(pro, &g, c); 1580 transform_from_geo(pro, &g, c);
1507 if (draw) 1581 if (draw)
1508 navit_draw(this_); 1582 navit_draw(this_);
1514 * @param navit The navit instance 1588 * @param navit The navit instance
1515 * @param c The coordinate to start routing to 1589 * @param c The coordinate to start routing to
1516 * @param description A label which allows the user to later identify this destination in the former destinations selection 1590 * @param description A label which allows the user to later identify this destination in the former destinations selection
1517 * @returns nothing 1591 * @returns nothing
1518 */ 1592 */
1519void
1520navit_set_destination(struct navit *this_, struct pcoord *c, const char *description, int async) 1593void navit_set_destination(struct navit *this_, struct pcoord *c, const char *description, int async)
1521{ 1594{
1522 //dbg(0,"EEnter\n"); 1595 ////DBG dbg(0,"EEnter\n");
1523 char *destination_file; 1596 char *destination_file;
1524 if (c) { 1597 if (c)
1598 {
1525 this_->destination=*c; 1599 this_->destination = *c;
1526 this_->destination_valid=1; 1600 this_->destination_valid = 1;
1527
1528 dbg(1, "navit->navit_set_destination %i\n", c->x); 1601 //dbg(0, "navit->navit_set_destination %i\n", c->x);
1529 dbg(1, "navit->navit_set_destination %i\n", c->y); 1602 //dbg(0, "navit->navit_set_destination %i\n", c->y);
1530 1603 }
1531 } else 1604 else
1605 {
1532 this_->destination_valid=0; 1606 this_->destination_valid = 0;
1607 }
1533 destination_file = bookmarks_get_destination_file(TRUE); 1608 //destination_file = bookmarks_get_destination_file(TRUE);
1534 bookmarks_append_coord(this_->bookmarks, destination_file, c, 1, "former_destination", description, NULL, this_->recentdest_count); 1609 //bookmarks_append_coord(this_->bookmarks, destination_file, c, 1, "former_destination", description, NULL, this_->recentdest_count);
1535 g_free(destination_file); 1610 //g_free(destination_file);
1536 callback_list_call_attr_0(this_->attr_cbl, attr_destination); 1611 callback_list_call_attr_0(this_->attr_cbl, attr_destination);
1537 if (this_->route) { 1612 if (this_->route)
1613 {
1614 //dbg(0, "navit->navit_set_destination 2: %i %i\n", c->x, c->y);
1615
1538 route_set_destination(this_->route, c, async); 1616 route_set_destination(this_->route, c, async);
1539
1540 if (this_->ready == 3) 1617 if (this_->ready == 3)
1618 {
1541 navit_draw(this_); 1619 navit_draw(this_);
1620 }
1621 }
1622}
1623
1624/**
1625 * add a waypoint to an active route
1626 *
1627 * @param navit The navit instance
1628 * @param c The coordinate of the waypoint
1629 * @param description A dummy string
1630 * @returns nothing
1631 */
1632void navit_add_waypoint_to_route(struct navit *this_, struct pcoord *c, const char *description, int async)
1633{
1634 if (this_->destination_valid == 1)
1635 {
1636 //int count = 0;
1637 //count = g_list_length(this_->route->destinations);
1638 //DBG dbg(0, "count=%d\n", count);
1639
1640 //dbg(0, "navit->navit_add_waypoint_to_route 1: %i %i\n", c->x, c->y);
1641
1642 route_add_destination(this_->route, c, async);
1643
1644 this_->destination = *c;
1645 this_->destination_valid = 1;
1646 }
1647 else
1648 {
1649 //dbg(0, "navit->navit_add_waypoint_to_route 2: %i %i\n", c->x, c->y);
1650 navit_set_destination(this_, c, description, async);
1542 } 1651 }
1543} 1652}
1544 1653
1545/** 1654/**
1546 * Start the route computing to a given set of coordinates including waypoints 1655 * Start the route computing to a given set of coordinates including waypoints
1548 * @param navit The navit instance 1657 * @param navit The navit instance
1549 * @param c The coordinate to start routing to 1658 * @param c The coordinate to start routing to
1550 * @param description A label which allows the user to later identify this destination in the former destinations selection 1659 * @param description A label which allows the user to later identify this destination in the former destinations selection
1551 * @returns nothing 1660 * @returns nothing
1552 */ 1661 */
1553void
1554navit_set_destinations(struct navit *this_, struct pcoord *c, int count, const char *description, int async) 1662void navit_set_destinations(struct navit *this_, struct pcoord *c, int count, const char *description, int async)
1555{ 1663{
1556 //dbg(0,"EEnter\n"); 1664 ////DBG dbg(0,"EEnter\n");
1557 char *destination_file; 1665 char *destination_file;
1558 if (c && count) { 1666 if (c && count)
1667 {
1559 this_->destination=c[count-1]; 1668 this_->destination = c[count - 1];
1560 this_->destination_valid=1; 1669 this_->destination_valid = 1;
1670 //dbg(0, "navit->navit_set_destinations 1: %i %i\n", c[count-1].x, c[count-1].y);
1671 }
1561 } else 1672 else
1673 {
1562 this_->destination_valid=0; 1674 this_->destination_valid = 0;
1675 }
1563 destination_file = bookmarks_get_destination_file(TRUE); 1676 //destination_file = bookmarks_get_destination_file(TRUE);
1564 bookmarks_append_coord(this_->bookmarks, destination_file, c, count, "former_itinerary", description, NULL, this_->recentdest_count); 1677 //bookmarks_append_coord(this_->bookmarks, destination_file, c, count, "former_itinerary", description, NULL, this_->recentdest_count);
1565 g_free(destination_file); 1678 //g_free(destination_file);
1566 callback_list_call_attr_0(this_->attr_cbl, attr_destination); 1679 callback_list_call_attr_0(this_->attr_cbl, attr_destination);
1567 if (this_->route) { 1680 if (this_->route)
1681 {
1568 route_set_destinations(this_->route, c, count, async); 1682 route_set_destinations(this_->route, c, count, async);
1569
1570 if (this_->ready == 3) 1683 if (this_->ready == 3)
1684 {
1571 navit_draw(this_); 1685 navit_draw(this_);
1686 }
1572 } 1687 }
1573} 1688}
1574 1689
1575/** 1690/**
1576 * @brief Checks if a route is calculated 1691 * @brief Checks if a route is calculated
1578 * This function checks if a route is calculated. 1693 * This function checks if a route is calculated.
1579 * 1694 *
1580 * @param this_ The navit struct whose route should be checked. 1695 * @param this_ The navit struct whose route should be checked.
1581 * @return True if the route is set, false otherwise. 1696 * @return True if the route is set, false otherwise.
1582 */ 1697 */
1583int
1584navit_check_route(struct navit *this_) 1698int navit_check_route(struct navit *this_)
1585{ 1699{
1586 //dbg(0,"EEnter\n"); 1700 ////DBG dbg(0,"EEnter\n");
1587 if (this_->route) { 1701 if (this_->route)
1702 {
1588 return route_get_path_set(this_->route); 1703 return route_get_path_set(this_->route);
1589 } 1704 }
1590 1705
1591 return 0; 1706 return 0;
1592} 1707}
1593 1708
1594static int
1595navit_former_destinations_active(struct navit *this_) 1709static int navit_former_destinations_active(struct navit *this_)
1596{ 1710{
1597 //dbg(0,"EEnter\n"); 1711 ////DBG dbg(0,"EEnter\n");
1712
1713 return 0;
1714 // disable this function!!
1715
1716
1598 char *destination_file = bookmarks_get_destination_file(FALSE); 1717 char *destination_file = bookmarks_get_destination_file(FALSE);
1599 FILE *f; 1718 FILE *f;
1600 int active=0; 1719 int active = 0;
1601 char buffer[3]; 1720 char buffer[3];
1602 f=fopen(destination_file,"r"); 1721 f = fopen(destination_file, "r");
1603 if (f) { 1722 if (f)
1723 {
1604 if(!fseek(f, -2, SEEK_END) && fread(buffer, 2, 1, f) == 1 && (buffer[0]!='\n' || buffer[1]!='\n')) 1724 if (!fseek(f, -2, SEEK_END) && fread(buffer, 2, 1, f) == 1 && (buffer[0] != '\n' || buffer[1] != '\n'))
1725 {
1605 active=1; 1726 active = 1;
1727 }
1606 fclose(f); 1728 fclose(f);
1607 } 1729 }
1608 g_free(destination_file); 1730 g_free(destination_file);
1731
1609 return active; 1732 return active;
1610} 1733}
1611 1734
1612static void
1613navit_add_former_destinations_from_file(struct navit *this_) 1735static void navit_add_former_destinations_from_file(struct navit *this_)
1614{ 1736{
1615 //dbg(0,"EEnter\n"); 1737 ////DBG dbg(0,"EEnter\n");
1616 char *destination_file = bookmarks_get_destination_file(FALSE); 1738 char *destination_file = bookmarks_get_destination_file(FALSE);
1617 struct attr *attrs[4]; 1739 struct attr *attrs[4];
1618 struct map_rect *mr; 1740 struct map_rect *mr;
1619 struct item *item; 1741 struct item *item;
1620 int i,valid=0,count=0; 1742 int i, valid = 0, count = 0;
1621 struct coord c[16]; 1743 struct coord c[16];
1622 struct pcoord pc[16]; 1744 struct pcoord pc[16];
1623 struct attr parent; 1745 struct attr parent;
1624 struct attr type; 1746 struct attr type;
1625 struct attr data; 1747 struct attr data;
1626 struct attr flags; 1748 struct attr flags;
1627 1749
1628 parent.type=attr_navit; 1750 parent.type = attr_navit;
1629 parent.u.navit=this_; 1751 parent.u.navit = this_;
1630 1752
1631 type.type=attr_type; 1753 type.type = attr_type;
1632 type.u.str="textfile"; 1754 type.u.str = "textfile";
1633 1755
1634 data.type=attr_data; 1756 data.type = attr_data;
1635 data.u.str=destination_file; 1757 data.u.str = destination_file;
1636 1758
1637 flags.type=attr_flags; 1759 flags.type = attr_flags;
1638 flags.u.num=1; 1760 flags.u.num = 1;
1639 1761
1640 attrs[0]=&type; attrs[1]=&data; attrs[2]=&flags; attrs[3]=NULL; 1762 attrs[0] = &type;
1763 attrs[1] = &data;
1764 attrs[2] = &flags;
1765 attrs[3] = NULL;
1641 1766
1642 this_->former_destination=map_new(&parent, attrs); 1767 this_->former_destination = map_new(&parent, attrs);
1643 g_free(destination_file); 1768 g_free(destination_file);
1644 if (!this_->route || !navit_former_destinations_active(this_)) 1769 if (!this_->route || !navit_former_destinations_active(this_))
1645 return; 1770 return;
1646 mr=map_rect_new(this_->former_destination, NULL); 1771 mr = map_rect_new(this_->former_destination, NULL);
1647 while ((item=map_rect_get_item(mr))) { 1772 while ((item = map_rect_get_item(mr)))
1773 {
1648 if ((item->type == type_former_destination || item->type == type_former_itinerary || item->type == type_former_itinerary_part) && (count=item_coord_get(item, c, 16))) 1774 if ((item->type == type_former_destination || item->type == type_former_itinerary || item->type == type_former_itinerary_part) && (count = item_coord_get(item, c, 16)))
1649 valid=1; 1775 valid = 1;
1650 } 1776 }
1651 map_rect_destroy(mr); 1777 map_rect_destroy(mr);
1652 if (valid && count > 0) { 1778 if (valid && count > 0)
1779 {
1653 for (i = 0 ; i < count ; i++) { 1780 for (i = 0; i < count; i++)
1781 {
1654 pc[i].pro=map_projection(this_->former_destination); 1782 pc[i].pro = map_projection(this_->former_destination);
1655 pc[i].x=c[i].x; 1783 pc[i].x = c[i].x;
1656 pc[i].y=c[i].y; 1784 pc[i].y = c[i].y;
1657 } 1785 }
1658 if (count == 1) 1786 if (count == 1)
1787 {
1659 route_set_destination(this_->route, &pc[0], 1); 1788 route_set_destination(this_->route, &pc[0], 1);
1789 }
1660 else 1790 else
1791 {
1661 route_set_destinations(this_->route, pc, count, 1); 1792 route_set_destinations(this_->route, pc, count, 1);
1793 }
1662 this_->destination=pc[count-1]; 1794 this_->destination = pc[count - 1];
1663 this_->destination_valid=1; 1795 this_->destination_valid = 1;
1664 } 1796 }
1665} 1797}
1666 1798
1667
1668void
1669navit_textfile_debug_log(struct navit *this_, const char *fmt, ...) 1799void navit_textfile_debug_log(struct navit *this_, const char *fmt, ...)
1670{ 1800{
1671 //dbg(0,"EEnter\n"); 1801 ////DBG dbg(0,"EEnter\n");
1672 va_list ap; 1802 va_list ap;
1673 char *str1,*str2; 1803 char *str1, *str2;
1674 va_start(ap, fmt); 1804 va_start(ap, fmt);
1675 if (this_->textfile_debug_log && this_->vehicle) { 1805 if (this_->textfile_debug_log && this_->vehicle)
1806 {
1676 str1=g_strdup_vprintf(fmt, ap); 1807 str1 = g_strdup_vprintf(fmt, ap);
1677 str2=g_strdup_printf("0x%x 0x%x%s%s\n", this_->vehicle->coord.x, this_->vehicle->coord.y, strlen(str1) ? " " : "", str1); 1808 str2 = g_strdup_printf("0x%x 0x%x%s%s\n", this_->vehicle->coord.x, this_->vehicle->coord.y, strlen(str1) ? " " : "", str1);
1678 log_write(this_->textfile_debug_log, str2, strlen(str2), 0); 1809 log_write(this_->textfile_debug_log, str2, strlen(str2), 0);
1679 g_free(str2); 1810 g_free(str2);
1680 g_free(str1); 1811 g_free(str1);
1681 } 1812 }
1682 va_end(ap); 1813 va_end(ap);
1683} 1814}
1684 1815
1685void
1686navit_textfile_debug_log_at(struct navit *this_, struct pcoord *pc, const char *fmt, ...) 1816void navit_textfile_debug_log_at(struct navit *this_, struct pcoord *pc, const char *fmt, ...)
1687{ 1817{
1688 //dbg(0,"EEnter\n"); 1818 ////DBG dbg(0,"EEnter\n");
1689 va_list ap; 1819 va_list ap;
1690 char *str1,*str2; 1820 char *str1, *str2;
1691 va_start(ap, fmt); 1821 va_start(ap, fmt);
1692 if (this_->textfile_debug_log && this_->vehicle) { 1822 if (this_->textfile_debug_log && this_->vehicle)
1823 {
1693 str1=g_strdup_vprintf(fmt, ap); 1824 str1 = g_strdup_vprintf(fmt, ap);
1694 str2=g_strdup_printf("0x%x 0x%x%s%s\n", pc->x, pc->y, strlen(str1) ? " " : "", str1); 1825 str2 = g_strdup_printf("0x%x 0x%x%s%s\n", pc->x, pc->y, strlen(str1) ? " " : "", str1);
1695 log_write(this_->textfile_debug_log, str2, strlen(str2), 0); 1826 log_write(this_->textfile_debug_log, str2, strlen(str2), 0);
1696 g_free(str2); 1827 g_free(str2);
1697 g_free(str1); 1828 g_free(str1);
1698 } 1829 }
1699 va_end(ap); 1830 va_end(ap);
1700} 1831}
1701 1832
1702void
1703navit_say(struct navit *this_, char *text) 1833void navit_say(struct navit *this_, char *text)
1704{ 1834{
1705 //dbg(0,"EEnter\n"); 1835 ////DBG dbg(0,"EEnter\n");
1706 if(this_->speech) { 1836 if (this_->speech)
1837 {
1707 speech_say(this_->speech, text); 1838 speech_say(this_->speech, text);
1708 } 1839 }
1709} 1840}
1710 1841
1711/** 1842/**
1712 * @brief Toggles the navigation announcer for navit 1843 * @brief Toggles the navigation announcer for navit
1713 * @param this_ The navit object 1844 * @param this_ The navit object
1714 */ 1845 */
1715static void
1716navit_cmd_announcer_toggle(struct navit *this_) 1846static void navit_cmd_announcer_toggle(struct navit *this_)
1717{ 1847{
1718 struct attr attr, speechattr; 1848 struct attr attr, speechattr;
1719 1849
1720 // search for the speech attribute 1850 // search for the speech attribute
1721 if(!navit_get_attr(this_, attr_speech, &speechattr, NULL)) 1851 if (!navit_get_attr(this_, attr_speech, &speechattr, NULL))
1722 return; 1852 return;
1723 // find out if the corresponding attribute attr_active has been set 1853 // find out if the corresponding attribute attr_active has been set
1724 if(speech_get_attr(speechattr.u.speech, attr_active, &attr, NULL)) { 1854 if (speech_get_attr(speechattr.u.speech, attr_active, &attr, NULL))
1855 {
1725 // flip it then... 1856 // flip it then...
1726 attr.u.num = !attr.u.num; 1857 attr.u.num = !attr.u.num;
1727 } else { 1858 }
1859 else
1860 {
1728 // otherwise disable it because voice is enabled by default 1861 // otherwise disable it because voice is enabled by default
1729 attr.type = attr_active; 1862 attr.type = attr_active;
1730 attr.u.num = 0; 1863 attr.u.num = 0;
1731 } 1864 }
1732 1865
1733 // apply the new state 1866 // apply the new state
1734 if(!speech_set_attr(speechattr.u.speech, &attr)) 1867 if (!speech_set_attr(speechattr.u.speech, &attr))
1735 return; 1868 return;
1736 1869
1737 // announce that the speech attribute has changed 1870 // announce that the speech attribute has changed
1738 callback_list_call_attr_0(this_->attr_cbl, attr_speech); 1871 callback_list_call_attr_0(this_->attr_cbl, attr_speech);
1739} 1872}
1740 1873
1741
1742
1743
1744void
1745navit_cmd_announcer_on(struct navit *this_) 1874void navit_cmd_announcer_on(struct navit *this_)
1746{ 1875{
1747 struct attr attr, speechattr; 1876 struct attr attr, speechattr;
1748 1877
1749 // search for the speech attribute 1878 // search for the speech attribute
1750 if(!navit_get_attr(this_, attr_speech, &speechattr, NULL)) 1879 if (!navit_get_attr(this_, attr_speech, &speechattr, NULL))
1751 return; 1880 return;
1752 1881
1753 attr.type = attr_active; 1882 attr.type = attr_active;
1754 attr.u.num = 1; 1883 attr.u.num = 1;
1755 1884
1756 // apply the new state 1885 // apply the new state
1757 if(!speech_set_attr(speechattr.u.speech, &attr)) 1886 if (!speech_set_attr(speechattr.u.speech, &attr))
1758 return; 1887 return;
1759 1888
1760 // announce that the speech attribute has changed 1889 // announce that the speech attribute has changed
1761 callback_list_call_attr_0(this_->attr_cbl, attr_speech); 1890 callback_list_call_attr_0(this_->attr_cbl, attr_speech);
1762} 1891}
1763 1892
1764
1765void
1766navit_cmd_announcer_off(struct navit *this_) 1893void navit_cmd_announcer_off(struct navit *this_)
1767{ 1894{
1768 struct attr attr, speechattr; 1895 struct attr attr, speechattr;
1769 1896
1770 // search for the speech attribute 1897 // search for the speech attribute
1771 if(!navit_get_attr(this_, attr_speech, &speechattr, NULL)) 1898 if (!navit_get_attr(this_, attr_speech, &speechattr, NULL))
1772 return; 1899 return;
1773 1900
1774 attr.type = attr_active; 1901 attr.type = attr_active;
1775 attr.u.num = 0; 1902 attr.u.num = 0;
1776 1903
1777 // apply the new state 1904 // apply the new state
1778 if(!speech_set_attr(speechattr.u.speech, &attr)) 1905 if (!speech_set_attr(speechattr.u.speech, &attr))
1779 return; 1906 return;
1780 1907
1781 // announce that the speech attribute has changed 1908 // announce that the speech attribute has changed
1782 callback_list_call_attr_0(this_->attr_cbl, attr_speech); 1909 callback_list_call_attr_0(this_->attr_cbl, attr_speech);
1783} 1910}
1784 1911
1785
1786
1787void
1788navit_speak(struct navit *this_) 1912void navit_speak(struct navit *this_)
1789{ 1913{
1790 //dbg(0,"EEnter\n"); 1914 ////DBG dbg(0,"EEnter\n");
1791 struct navigation *nav=this_->navigation; 1915 struct navigation *nav = this_->navigation;
1792 struct map *map=NULL; 1916 struct map *map = NULL;
1793 struct map_rect *mr=NULL; 1917 struct map_rect *mr = NULL;
1794 struct item *item; 1918 struct item *item;
1795 struct attr attr; 1919 struct attr attr;
1796 1920
1797 if (!speech_get_attr(this_->speech, attr_active, &attr, NULL)) 1921 if (!speech_get_attr(this_->speech, attr_active, &attr, NULL))
1798 attr.u.num = 1; 1922 attr.u.num = 1;
1799 dbg(1, "this_.speech->active %i\n", attr.u.num); 1923 // dbg(1, "this_.speech->active %i\n", attr.u.num);
1800 if(!attr.u.num) 1924 if (!attr.u.num)
1801 return; 1925 return;
1802 1926
1803 if (nav) 1927 if (nav)
1804 map=navigation_get_map(nav); 1928 map = navigation_get_map(nav);
1805 if (map) 1929 if (map)
1806 mr=map_rect_new(map, NULL); 1930 mr = map_rect_new(map, NULL);
1807 if (mr) { 1931 if (mr)
1932 {
1808 while ((item=map_rect_get_item(mr)) && (item->type == type_nav_position || item->type == type_nav_none)); 1933 while ((item = map_rect_get_item(mr)) && (item->type == type_nav_position || item->type == type_nav_none))
1934 ;
1809 if (item && item_attr_get(item, attr_navigation_speech, &attr)) { 1935 if (item && item_attr_get(item, attr_navigation_speech, &attr))
1936 {
1810 speech_say(this_->speech, attr.u.str); 1937 speech_say(this_->speech, attr.u.str);
1811 navit_add_message(this_, attr.u.str); 1938 //navit_add_message(this_, attr.u.str);
1812 navit_textfile_debug_log(this_, "type=announcement label=\"%s\"", attr.u.str); 1939 navit_textfile_debug_log(this_, "type=announcement label=\"%s\"", attr.u.str);
1813 } 1940 }
1814 map_rect_destroy(mr); 1941 map_rect_destroy(mr);
1815 } 1942 }
1816} 1943}
1817 1944
1818static void
1819navit_window_roadbook_update(struct navit *this_) 1945static void navit_window_roadbook_update(struct navit *this_)
1820{ 1946{
1821 //dbg(0,"EEnter\n"); 1947 ////DBG dbg(0,"EEnter\n");
1822 struct navigation *nav=this_->navigation; 1948 struct navigation *nav = this_->navigation;
1823 struct map *map=NULL; 1949 struct map *map = NULL;
1824 struct map_rect *mr=NULL; 1950 struct map_rect *mr = NULL;
1825 struct item *item; 1951 struct item *item;
1826 struct attr attr; 1952 struct attr attr;
1827 struct param_list param[5]; 1953 struct param_list param[5];
1828 int secs; 1954 int secs;
1829 1955
1830 dbg(1,"enter\n"); 1956 // dbg(1, "enter\n");
1831 datawindow_mode(this_->roadbook_window, 1); 1957 datawindow_mode(this_->roadbook_window, 1);
1832 if (nav) 1958 if (nav)
1833 map=navigation_get_map(nav); 1959 map = navigation_get_map(nav);
1834 if (map) 1960 if (map)
1835 mr=map_rect_new(map, NULL); 1961 mr = map_rect_new(map, NULL);
1836 //dbg(0,"nav=%p map=%p mr=%p\n", nav, map, mr); 1962 ////DBG dbg(0,"nav=%p map=%p mr=%p\n", nav, map, mr);
1837 if (mr) { 1963 if (mr)
1964 {
1838 //dbg(0,"while loop\n"); 1965 ////DBG dbg(0,"while loop\n");
1839 while ((item=map_rect_get_item(mr))) { 1966 while ((item = map_rect_get_item(mr)))
1967 {
1840 //dbg(0,"item=%p\n", item); 1968 ////DBG dbg(0,"item=%p\n", item);
1841 attr.u.str=NULL; 1969 attr.u.str = NULL;
1842 if (item->type != type_nav_position) { 1970 if (item->type != type_nav_position)
1971 {
1843 item_attr_get(item, attr_navigation_long, &attr); 1972 item_attr_get(item, attr_navigation_long, &attr);
1844 if (attr.u.str == NULL) { 1973 if (attr.u.str == NULL)
1974 {
1845 continue; 1975 continue;
1846 } 1976 }
1847 dbg(2, "Command='%s'\n", attr.u.str); 1977 dbg(2, "Command='%s'\n", attr.u.str);
1848 param[0].value=g_strdup(attr.u.str); 1978 param[0].value = g_strdup(attr.u.str);
1979 }
1849 } else 1980 else
1850 param[0].value=_("Position"); 1981 param[0].value = _("Position");
1851 param[0].name=_("Command"); 1982 param[0].name = _("Command");
1852 1983
1853 item_attr_get(item, attr_length, &attr); 1984 item_attr_get(item, attr_length, &attr);
1854 dbg(2, "Length=%d\n", attr.u.num); 1985 dbg(2, "Length=%d\n", attr.u.num);
1855 param[1].name=_("Length"); 1986 param[1].name = _("Length");
1856 1987
1857 if ( attr.u.num >= 2000 ) 1988 if (attr.u.num >= 2000)
1858 { 1989 {
1859 param[1].value=g_strdup_printf("%5.1f %s",(float)attr.u.num / 1000, _("km") ); 1990 param[1].value = g_strdup_printf("%5.1f %s", (float) attr.u.num / 1000, _("km"));
1860 } 1991 }
1861 else 1992 else
1862 { 1993 {
1863 param[1].value=g_strdup_printf("%7d %s",attr.u.num, _("m")); 1994 param[1].value = g_strdup_printf("%7d %s", attr.u.num, _("m"));
1864 } 1995 }
1865 1996
1866 item_attr_get(item, attr_time, &attr); 1997 item_attr_get(item, attr_time, &attr);
1867 dbg(2, "Time=%d\n", attr.u.num); 1998 dbg(2, "Time=%d\n", attr.u.num);
1868 secs=attr.u.num/10; 1999 secs = attr.u.num / 10;
1869 param[2].name=_("Time"); 2000 param[2].name = _("Time");
1870 if ( secs >= 3600 ) 2001 if (secs >= 3600)
1871 { 2002 {
1872 param[2].value=g_strdup_printf("%d:%02d:%02d",secs / 60, ( secs / 60 ) % 60 , secs % 60); 2003 param[2].value = g_strdup_printf("%d:%02d:%02d", secs / 60, (secs / 60) % 60, secs % 60);
1873 } 2004 }
1874 else 2005 else
1875 { 2006 {
1876 param[2].value=g_strdup_printf("%d:%02d",secs / 60, secs % 60); 2007 param[2].value = g_strdup_printf("%d:%02d", secs / 60, secs % 60);
1877 } 2008 }
1878 2009
1879 item_attr_get(item, attr_destination_length, &attr); 2010 item_attr_get(item, attr_destination_length, &attr);
1880 dbg(2, "Destlength=%d\n", attr.u.num); 2011 dbg(2, "Destlength=%d\n", attr.u.num);
1881 param[3].name=_("Destination Length"); 2012 param[3].name = _("Destination Length");
1882 if ( attr.u.num >= 2000 ) 2013 if (attr.u.num >= 2000)
1883 { 2014 {
1884 param[3].value=g_strdup_printf("%5.1f %s",(float)attr.u.num / 1000, _("km") ); 2015 param[3].value = g_strdup_printf("%5.1f %s", (float) attr.u.num / 1000, _("km"));
1885 } 2016 }
1886 else 2017 else
1887 { 2018 {
1888 param[3].value=g_strdup_printf("%d %s",attr.u.num, _("m")); 2019 param[3].value = g_strdup_printf("%d %s", attr.u.num, _("m"));
1889 } 2020 }
1890 2021
1891 item_attr_get(item, attr_destination_time, &attr); 2022 item_attr_get(item, attr_destination_time, &attr);
1892 dbg(2, "Desttime=%d\n", attr.u.num); 2023 dbg(2, "Desttime=%d\n", attr.u.num);
1893 secs=attr.u.num/10; 2024 secs = attr.u.num / 10;
1894 param[4].name=_("Destination Time"); 2025 param[4].name = _("Destination Time");
1895 if ( secs >= 3600 ) 2026 if (secs >= 3600)
1896 { 2027 {
1897 param[4].value=g_strdup_printf("%d:%02d:%02d",secs / 3600, (secs / 60 ) % 60 , secs % 60); 2028 param[4].value = g_strdup_printf("%d:%02d:%02d", secs / 3600, (secs / 60) % 60, secs % 60);
1898 } 2029 }
1899 else 2030 else
1900 { 2031 {
1901 param[4].value=g_strdup_printf("%d:%02d",secs / 60, secs % 60); 2032 param[4].value = g_strdup_printf("%d:%02d", secs / 60, secs % 60);
1902 } 2033 }
1903 datawindow_add(this_->roadbook_window, param, 5); 2034 datawindow_add(this_->roadbook_window, param, 5);
1904 } 2035 }
1905 map_rect_destroy(mr); 2036 map_rect_destroy(mr);
1906 } 2037 }
1907 datawindow_mode(this_->roadbook_window, 0); 2038 datawindow_mode(this_->roadbook_window, 0);
1908} 2039}
1909 2040
1910void
1911navit_window_roadbook_destroy(struct navit *this_) 2041void navit_window_roadbook_destroy(struct navit *this_)
1912{ 2042{
1913 //dbg(0, "enter\n"); 2043 ////DBG dbg(0, "enter\n");
1914 navigation_unregister_callback(this_->navigation, attr_navigation_long, this_->roadbook_callback); 2044 navigation_unregister_callback(this_->navigation, attr_navigation_long, this_->roadbook_callback);
1915 this_->roadbook_window=NULL; 2045 this_->roadbook_window = NULL;
1916 this_->roadbook_callback=NULL; 2046 this_->roadbook_callback = NULL;
1917} 2047}
1918void
1919navit_window_roadbook_new(struct navit *this_) 2048void navit_window_roadbook_new(struct navit *this_)
1920{ 2049{
1921 if (!this_->gui || this_->roadbook_callback || this_->roadbook_window) { 2050 if (!this_->gui || this_->roadbook_callback || this_->roadbook_window)
2051 {
1922 return; 2052 return;
1923 } 2053 }
1924 2054
1925 this_->roadbook_callback=callback_new_1(callback_cast(navit_window_roadbook_update), this_); 2055 this_->roadbook_callback = callback_new_1(callback_cast(navit_window_roadbook_update), this_);
1926 navigation_register_callback(this_->navigation, attr_navigation_long, this_->roadbook_callback); 2056 navigation_register_callback(this_->navigation, attr_navigation_long, this_->roadbook_callback);
1927 this_->roadbook_window=gui_datawindow_new(this_->gui, _("Roadbook"), NULL, callback_new_1(callback_cast(navit_window_roadbook_destroy), this_)); 2057 this_->roadbook_window = gui_datawindow_new(this_->gui, _("Roadbook"), NULL, callback_new_1(callback_cast(navit_window_roadbook_destroy), this_));
1928 navit_window_roadbook_update(this_); 2058 navit_window_roadbook_update(this_);
1929} 2059}
1930 2060
1931void
1932navit_remove_all_maps(struct navit *this_) 2061void navit_remove_all_maps(struct navit *this_)
1933{ 2062{
1934 struct mapset *ms; 2063 struct mapset *ms;
1935 struct map *map3; 2064 struct map *map3;
1936 2065
2066 // first: stop navigation!
2067 //if (global_navit->destination_valid != 0)
2068 //{
2069 navit_set_destination(global_navit, NULL, NULL, 0);
2070 //}
2071
2072
2073 if (this_->route)
2074 {
2075 struct attr callback;
2076 // this_->route_cb=callback_new_attr_1(callback_cast(navit_redraw_route), attr_route_status, this_);
2077 callback.type=attr_callback;
2078 callback.u.callback=this_->route_cb;
2079 route_remove_attr(this_->route, &callback);
2080
2081 this_->route->ms = NULL;
2082 // route_set_mapset(this_->route, ms);
2083 // route_set_projection(this_->route, transform_get_projection(this_->trans));
2084
2085 //*********route_destroy(this_->route);
2086
2087 //route_path_destroy(this_->route->path2,1);
2088 //this_->route->path2 = NULL;
2089 //route_graph_destroy(this_->route->graph);
2090 //this_->route->graph=NULL;
2091 }
2092
2093 /*
2094 map_rect_destroy(displaylist->mr);
2095 if (!route_selection)
2096 map_selection_destroy(displaylist->sel);
2097 mapset_close(displaylist->msh);
2098 displaylist->mr=NULL;
2099 displaylist->sel=NULL;
2100 displaylist->m=NULL;
2101 displaylist->msh=NULL;
2102 profile(1,"callback\n");
2103 callback_call_1(displaylist->cb, cancel);
2104 */
2105
2106 struct displaylist *dl = navit_get_displaylist(this_);
2107 dl->m = NULL;
2108 dl->msh = NULL;
2109
1937 if (this_->mapsets) 2110 if (this_->mapsets)
1938 { 2111 {
1939 struct mapset_handle *msh; 2112 struct mapset_handle *msh;
1940 ms=this_->mapsets->data; 2113 ms = this_->mapsets->data;
1941 msh=mapset_open(ms); 2114 msh = mapset_open(ms);
2115 ////DBG dbg(0,"removing map bb0\n");
1942 while (msh && (map3=mapset_next(msh, 0))) 2116 while (msh && (map3 = mapset_next(msh, 0)))
1943 { 2117 {
2118 ////DBG dbg(0,"removing map bb1\n");
1944 struct attr map_name_attr; 2119 struct attr map_name_attr;
1945 if (map_get_attr(map3,attr_name, &map_name_attr,NULL)) 2120 if (map_get_attr(map3, attr_name, &map_name_attr, NULL))
1946 { 2121 {
1947 //dbg(0,"map name=%s",map_name_attr.u.str); 2122 //DBG dbg(0, "map name=%s", map_name_attr.u.str);
1948 if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0) 2123 if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0)
1949 { 2124 {
1950 //dbg(0,"removing map\n"); 2125 //DBG dbg(0, "removing map a0\n");
2126 struct attr active;
2127 active.type = attr_active;
2128 active.u.num = 0;
2129 //map_set_attr(map3, &active);
2130
2131 //DBG dbg(0, "removing map a1\n");
1951 struct attr map_attr; 2132 struct attr map_attr;
1952 map_attr.u.map=map3; 2133 map_attr.u.map = map3;
1953 map_attr.type=attr_map; 2134 map_attr.type = attr_map;
1954 mapset_remove_attr(ms, &map_attr); 2135 mapset_remove_attr(ms, &map_attr);
2136
2137 //DBG dbg(0, "removing map a2\n");
2138 map3->refcount = 1;
1955 map_destroy(map3); 2139 map_destroy(map3);
2140 //DBG dbg(0, "removing map a3\n");
2141 map3 = NULL;
1956 } 2142 }
1957 } 2143 }
1958 } 2144 }
1959 mapset_close(msh); 2145 mapset_close(msh);
2146 //DBG dbg(0, "removing map bb4\n");
1960 } 2147 }
1961}
1962 2148
1963void 2149 dl->ms = this_->mapsets->data;
2150
2151 // int async = 0;
2152 // transform_setup_source_rect(this_->trans);
2153 // graphics_draw(this_->gra, this_->displaylist, this_->mapsets->data, this_->trans, this_->layout_current, async, NULL, this_->graphics_flags|1);
2154 //this_->displaylist->ms=this_->mapsets->data;
2155
2156}
2157
1964navit_add_all_maps(struct navit *this_) 2158void navit_add_all_maps(struct navit *this_)
1965{ 2159{
1966 struct mapset *ms;
1967 struct map *map3; 2160 struct map *map3;
1968 2161
1969 if (this_->mapsets) 2162 if (this_->mapsets)
1970 { 2163 {
2164 //DBG dbg(0, "xADDx all maps - start\n");
2165
2166 struct mapset *ms;
1971 ms=this_->mapsets->data; 2167 ms = this_->mapsets->data;
1972 2168
1973 struct attr type; 2169 struct attr type;
1974 struct attr parent; 2170 struct attr parent;
1975 struct attr data; 2171 struct attr data;
1976 struct attr flags; 2172 struct attr flags;
1977 struct map *map2; 2173 struct map *map2;
1978 struct attr map2_attr; 2174 struct attr map2_attr;
1979 struct attr *attrs[4]; 2175 struct attr *attrs[4];
1980 char *map_file; 2176 char *map_file;
1981 2177
1982 parent.type=attr_navit; 2178 parent.type = attr_navit;
1983 parent.u.navit=this_; 2179 parent.u.navit = this_;
1984 type.type=attr_type; 2180 type.type = attr_type;
1985 type.u.str="binfile"; 2181 type.u.str = "binfile";
1986 data.type=attr_data; 2182 data.type = attr_data;
1987 map_file=g_strdup("/sdcard/zanavi/maps/borders.bin"); 2183 map_file = g_strdup_printf("%sborders.bin", navit_maps_dir);
1988 data.u.str=map_file; 2184 data.u.str = map_file;
1989 2185
1990 //dbg(0,"map name=%s",map_file); 2186 ////DBG dbg(0,"map name=%s",map_file);
1991 2187
1992 flags.type=attr_flags; 2188 flags.type = attr_flags;
1993 flags.u.num=0; 2189 flags.u.num = 0;
1994 attrs[0]=&type; attrs[1]=&data; attrs[2]=&flags; attrs[3]=NULL; 2190 attrs[0] = &type;
2191 attrs[1] = &data;
2192 attrs[2] = &flags;
2193 attrs[3] = NULL;
1995 map2=map_new(&parent, attrs); 2194 map2 = map_new(&parent, attrs);
1996 if (map2) 2195 if (map2)
1997 { 2196 {
1998 map2_attr.u.data=map2; 2197 map2_attr.u.data = map2;
1999 map2_attr.type=attr_map; 2198 map2_attr.type = attr_map;
2000 mapset_add_attr_name(ms, &map2_attr); 2199 // mapset_add_attr_name(ms, &map2_attr);
2200 mapset_add_attr_name_str(ms, &map2_attr, "/sdcard/zanavi/maps/borders.bin");
2201 struct attr active;
2202 active.type = attr_active;
2203 active.u.num = 0;
2204 //map_set_attr(map2, &active);
2001 } 2205 }
2002 g_free(map_file); 2206 g_free(map_file);
2003 2207
2004 parent.type=attr_navit; 2208 parent.type = attr_navit;
2005 parent.u.navit=this_; 2209 parent.u.navit = this_;
2006 type.type=attr_type; 2210 type.type = attr_type;
2007 type.u.str="binfile"; 2211 type.u.str = "binfile";
2008 data.type=attr_data; 2212 data.type = attr_data;
2009 map_file=g_strdup("/sdcard/zanavi/maps/coastline.bin"); 2213 map_file = g_strdup_printf("%scoastline.bin", navit_maps_dir);
2010 data.u.str=map_file; 2214 data.u.str = map_file;
2011 2215
2012 //dbg(0,"map name=%s",map_file); 2216 ////DBG dbg(0,"map name=%s",map_file);
2013 2217
2014 flags.type=attr_flags; 2218 flags.type = attr_flags;
2015 flags.u.num=0; 2219 flags.u.num = 0;
2016 attrs[0]=&type; attrs[1]=&data; attrs[2]=&flags; attrs[3]=NULL; 2220 attrs[0] = &type;
2221 attrs[1] = &data;
2222 attrs[2] = &flags;
2223 attrs[3] = NULL;
2017 map2=map_new(&parent, attrs); 2224 map2 = map_new(&parent, attrs);
2018 if (map2) 2225 if (map2)
2019 { 2226 {
2020 map2_attr.u.data=map2; 2227 map2_attr.u.data = map2;
2021 map2_attr.type=attr_map; 2228 map2_attr.type = attr_map;
2022 mapset_add_attr_name(ms, &map2_attr); 2229 // mapset_add_attr_name(ms, &map2_attr);
2230 mapset_add_attr_name_str(ms, &map2_attr, "/sdcard/zanavi/maps/coastline.bin");
2231 struct attr active;
2232 active.type = attr_active;
2233 active.u.num = 0;
2234 //map_set_attr(map2, &active);
2023 } 2235 }
2024 g_free(map_file); 2236 g_free(map_file);
2025 2237
2026 int i=1; 2238 int i = 1;
2027 for(i = 1; i < 10;i++) 2239 for (i = 1; i < 10; i++)
2028 { 2240 {
2029 struct map *map22; 2241 struct map *map22;
2030 struct attr map22_attr; 2242 struct attr map22_attr;
2031 parent.type=attr_navit; 2243 parent.type = attr_navit;
2032 parent.u.navit=this_; 2244 parent.u.navit = this_;
2033 type.type=attr_type; 2245 type.type = attr_type;
2034 type.u.str="binfile"; 2246 type.u.str = "binfile";
2035 data.type=attr_data; 2247 data.type = attr_data;
2036 map_file=g_strdup_printf("/sdcard/zanavi/maps/navitmap_00%d.bin",i); 2248 map_file = g_strdup_printf("%snavitmap_00%d.bin", navit_maps_dir, i);
2037 data.u.str=map_file; 2249 data.u.str = map_file;
2038 //dbg(0,"map name=%s",map_file);
2039 flags.type=attr_flags; 2250 flags.type = attr_flags;
2040 flags.u.num=0; 2251 flags.u.num = 0;
2041 attrs[0]=&type; attrs[1]=&data; attrs[2]=&flags; attrs[3]=NULL; 2252 attrs[0] = &type;
2253 attrs[1] = &data;
2254 attrs[2] = &flags;
2255 attrs[3] = NULL;
2042 map22=map_new(&parent, attrs); 2256 map22 = map_new(&parent, attrs);
2043 if (map22) 2257 if (map22)
2044 { 2258 {
2259 //DBG dbg(0, "*add* map name=%s\n", map_file);
2045 map22_attr.u.data=map22; 2260 map22_attr.u.data = map22;
2046 map22_attr.type=attr_map; 2261 map22_attr.type = attr_map;
2047 mapset_add_attr_name(ms, &map22_attr); 2262 // mapset_add_attr_name(ms, &map22_attr);
2263 char *map_name_str;
2264 map_name_str = g_strdup_printf("/sdcard/zanavi/maps/navitmap_00%d.bin", i);
2265 mapset_add_attr_name_str(ms, &map22_attr, map_name_str);
2266 struct attr active;
2267 active.type = attr_active;
2268 active.u.num = 0;
2269 //map_set_attr(map22, &active);
2270 g_free(map_name_str);
2048 } 2271 }
2049 g_free(map_file); 2272 g_free(map_file);
2050 } 2273 }
2051 2274
2052 i=10; 2275 i = 10;
2053 for(i = 10; i < 21;i++) 2276 for (i = 10; i < 21; i++)
2054 { 2277 {
2055 parent.type=attr_navit; 2278 parent.type = attr_navit;
2056 parent.u.navit=this_; 2279 parent.u.navit = this_;
2057 type.type=attr_type; 2280 type.type = attr_type;
2058 type.u.str="binfile"; 2281 type.u.str = "binfile";
2059 data.type=attr_data; 2282 data.type = attr_data;
2060 map_file=g_strdup_printf("/sdcard/zanavi/maps/navitmap_0%d.bin",i); 2283 map_file = g_strdup_printf("%snavitmap_0%d.bin", navit_maps_dir, i);
2061 data.u.str=map_file; 2284 data.u.str = map_file;
2062 //dbg(0,"map name=%s",map_file); 2285 ////DBG dbg(0,"map name=%s",map_file);
2063 flags.type=attr_flags; 2286 flags.type = attr_flags;
2064 flags.u.num=0; 2287 flags.u.num = 0;
2065 attrs[0]=&type; attrs[1]=&data; attrs[2]=&flags; attrs[3]=NULL; 2288 attrs[0] = &type;
2289 attrs[1] = &data;
2290 attrs[2] = &flags;
2291 attrs[3] = NULL;
2066 map2=map_new(&parent, attrs); 2292 map2 = map_new(&parent, attrs);
2067 if (map2) 2293 if (map2)
2068 { 2294 {
2069 map2_attr.u.data=map2; 2295 map2_attr.u.data = map2;
2070 map2_attr.type=attr_map; 2296 map2_attr.type = attr_map;
2071 mapset_add_attr_name(ms, &map2_attr); 2297 // mapset_add_attr_name(ms, &map2_attr);
2298 char *map_name_str;
2299 map_name_str = g_strdup_printf("/sdcard/zanavi/maps/navitmap_0%d.bin", i);
2300 mapset_add_attr_name_str(ms, &map2_attr, map_name_str);
2301 struct attr active;
2302 active.type = attr_active;
2303 active.u.num = 0;
2304 //map_set_attr(map2, &active);
2305 g_free(map_name_str);
2072 } 2306 }
2073 g_free(map_file); 2307 g_free(map_file);
2074 } 2308 }
2075 } 2309 }
2076}
2077 2310
2078void 2311 /*
2079navit_reload_maps(struct navit *this_) 2312 if (this_->mapsets)
2080{ 2313 {
2081 navit_remove_all_maps(this_); 2314 struct mapset_handle *msh;
2082 navit_add_all_maps(this_); 2315 struct map *map;
2083}
2084
2085void
2086navit_init(struct navit *this_)
2087{
2088 //dbg(0,"EEnter\n");
2089 struct mapset *ms; 2316 struct mapset *ms;
2090 struct map *map;
2091 int callback;
2092 char *center_file;
2093 2317
2094 dbg(0,"enter gui %p graphics %p\n",this_->gui,this_->gra); 2318 //DBG dbg(0,"xx ms callbacks xx\n");
2095 2319
2096 if (!this_->gui && !(this_->flags & 2)) {
2097 dbg(0,"no gui\n");
2098 navit_destroy(this_);
2099 return;
2100 }
2101 if (!this_->gra && !(this_->flags & 1)) {
2102 dbg(0,"no graphics\n");
2103 navit_destroy(this_);
2104 return;
2105 }
2106 dbg(0,"Connecting gui to graphics\n");
2107 if (this_->gui && this_->gra && gui_set_graphics(this_->gui, this_->gra)) {
2108 struct attr attr_type_gui, attr_type_graphics;
2109 gui_get_attr(this_->gui, attr_type, &attr_type_gui, NULL);
2110 graphics_get_attr(this_->gra, attr_type, &attr_type_graphics, NULL);
2111 dbg(0,"failed to connect graphics '%s' to gui '%s'\n", attr_type_graphics.u.str, attr_type_gui.u.str);
2112 // dbg(0," Please see http://wiki.navit-project.org/index.php/Failed_to_connect_graphics_to_gui\n");
2113 // dbg(0," for explanations and solutions\n");
2114
2115 navit_destroy(this_);
2116 return;
2117 }
2118 if (this_->speech && this_->navigation) {
2119 struct attr speech;
2120 speech.type=attr_speech;
2121 speech.u.speech=this_->speech;
2122 navigation_set_attr(this_->navigation, &speech);
2123 }
2124 dbg(0,"Initializing graphics\n");
2125 dbg(0,"Setting Vehicle\n");
2126 navit_set_vehicle(this_, this_->vehicle);
2127 dbg(0,"Adding dynamic maps to mapset %p\n",this_->mapsets);
2128 if (this_->mapsets) {
2129 struct mapset_handle *msh;
2130 ms=this_->mapsets->data; 2320 ms=this_->mapsets->data;
2131 this_->progress_cb=callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_); 2321 this_->progress_cb=callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_);
2132 msh=mapset_open(ms); 2322 msh=mapset_open(ms);
2133 while (msh && (map=mapset_next(msh, 0))) { 2323 while (msh && (map=mapset_next(msh, 0)))
2324 {
2134 //pass new callback instance for each map in the mapset to make map callback list destruction work correctly 2325 //pass new callback instance for each map in the mapset to make map callback list destruction work correctly
2135 struct callback *pcb = callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_); 2326 struct callback *pcb = callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_);
2136 map_add_callback(map, pcb); 2327 map_add_callback(map, pcb);
2137 } 2328 }
2138 mapset_close(msh); 2329 mapset_close(msh);
2139 2330 }
2331 */
2332
2333 struct attr parent;
2334 parent.type = attr_navit;
2335 parent.u.navit = global_navit;
2336
2337 struct attr *attrs_r[2];
2338 attrs_r[0] = NULL;
2339 attrs_r[1] = NULL;
2340
2341 //***this_->route = route_new(&parent, attrs_r);
2342
2343
2344 //int async = 0;
2345 //transform_setup_source_rect(this_->trans);
2346 //graphics_draw(this_->gra, this_->displaylist, this_->mapsets->data, this_->trans, this_->layout_current, async, NULL, this_->graphics_flags|1);
2347
2348 struct displaylist *dl = navit_get_displaylist(this_);
2349 dl->ms = this_->mapsets->data;
2350 dl->m = NULL;
2351 dl->msh = NULL;
2352
2140 if (this_->route) { 2353 if (this_->route)
2141 if ((map=route_get_map(this_->route))) { 2354 {
2142 struct attr map_a,map_name; 2355 struct mapset *ms;
2143 map_a.type=attr_map; 2356 ms = this_->mapsets->data;
2144 map_a.u.map=map;
2145 map_name.type=attr_name;
2146 map_name.u.str="_ms_route";
2147 map_set_attr(map_a.u.map, &map_name);
2148 mapset_add_attr(ms, &map_a);
2149 }
2150 if ((map=route_get_graph_map(this_->route))) {
2151 struct attr map_a,active,map_name;
2152 map_a.type=attr_map;
2153 map_a.u.map=map;
2154 active.type=attr_active;
2155 active.u.num=0;
2156 map_name.type=attr_name;
2157 map_name.u.str="_ms_route_graph";
2158 map_set_attr(map_a.u.map, &map_name);
2159 mapset_add_attr(ms, &map_a);
2160 map_set_attr(map, &active);
2161 }
2162 route_set_mapset(this_->route, ms); 2357 route_set_mapset(this_->route, ms);
2163 route_set_projection(this_->route, transform_get_projection(this_->trans)); 2358
2164 }
2165 if (this_->tracking) {
2166 tracking_set_mapset(this_->tracking, ms);
2167 if (this_->route)
2168 tracking_set_route(this_->tracking, this_->route);
2169 }
2170 if (this_->navigation) {
2171 if ((map=navigation_get_map(this_->navigation))) {
2172 struct attr map_a,active,map_name;
2173 map_a.type=attr_map;
2174 map_a.u.map=map;
2175 active.type=attr_active;
2176 active.u.num=0;
2177 map_name.type=attr_name;
2178 map_name.u.str="_ms_navigation";
2179 map_set_attr(map_a.u.map, &map_name);
2180 mapset_add_attr(ms, &map_a);
2181 map_set_attr(map, &active);
2182 }
2183 }
2184 if (this_->tracking) {
2185 if ((map=tracking_get_map(this_->tracking))) {
2186 struct attr map_a,active,map_name;
2187 map_a.type=attr_map;
2188 map_a.u.map=map;
2189 active.type=attr_active;
2190 active.u.num=0;
2191 map_name.type=attr_name;
2192 map_name.u.str="_ms_tracking";
2193 map_set_attr(map_a.u.map, &map_name);
2194 mapset_add_attr(ms, &map_a);
2195 map_set_attr(map, &active);
2196 }
2197 }
2198 // *DISABLED* navit_add_former_destinations_from_file(this_);
2199 }
2200 if (this_->route) {
2201 struct attr callback; 2359 struct attr callback;
2202 this_->route_cb=callback_new_attr_1(callback_cast(navit_redraw_route), attr_route_status, this_); 2360 this_->route_cb=callback_new_attr_1(callback_cast(navit_redraw_route), attr_route_status, this_);
2203 callback.type=attr_callback; 2361 callback.type=attr_callback;
2204 callback.u.callback=this_->route_cb; 2362 callback.u.callback=this_->route_cb;
2205 route_add_attr(this_->route, &callback); 2363 route_add_attr(this_->route, &callback);
2364 // ***** route_set_projection(this_->route, transform_get_projection(this_->trans));
2365 }
2366
2367 if (this_->tracking)
2368 {
2369 struct mapset *ms;
2370 ms = this_->mapsets->data;
2371
2372 tracking_set_mapset(this_->tracking, ms);
2373 if (this_->route)
2374 {
2375 tracking_set_route(this_->tracking, this_->route);
2206 } 2376 }
2377 }
2378
2379
2380}
2381
2382void navit_reload_maps(struct navit *this_)
2383{
2384 navit_remove_all_maps(this_);
2385 navit_add_all_maps(this_);
2386}
2387
2388void navit_init(struct navit *this_)
2389{
2390 ////DBG dbg(0,"EEnter\n");
2391 struct mapset *ms;
2392 struct map *map;
2393 int callback;
2394 char *center_file;
2395
2396 // default value
2397 navit_maps_dir = "/sdcard/zanavi/maps/";
2398
2399 global_img_waypoint = NULL;
2400
2401 //DBG dbg(0, "enter gui %p graphics %p\n", this_->gui, this_->gra);
2402
2403 if (!this_->gui && !(this_->flags & 2))
2404 {
2405 dbg(0, "no gui\n");
2406 navit_destroy(this_);
2407 return;
2408 }
2409
2410 if (!this_->gra && !(this_->flags & 1))
2411 {
2412 dbg(0, "no graphics\n");
2413 navit_destroy(this_);
2414 return;
2415 }
2416
2417 //DBG dbg(0, "Connecting gui to graphics\n");
2418
2419 if (this_->gui && this_->gra && gui_set_graphics(this_->gui, this_->gra))
2420 {
2421 struct attr attr_type_gui, attr_type_graphics;
2422 gui_get_attr(this_->gui, attr_type, &attr_type_gui, NULL);
2423 graphics_get_attr(this_->gra, attr_type, &attr_type_graphics, NULL);
2424 //DBG dbg(0, "failed to connect graphics '%s' to gui '%s'\n", attr_type_graphics.u.str, attr_type_gui.u.str);
2425 // //DBG dbg(0," Please see http://wiki.navit-project.org/index.php/Failed_to_connect_graphics_to_gui\n");
2426 // //DBG dbg(0," for explanations and solutions\n");
2427
2428 dbg(0,"failed to connect to graphics\n");
2429 navit_destroy(this_);
2430 return;
2431 }
2432
2433 if (this_->speech && this_->navigation)
2434 {
2435 struct attr speech;
2436 speech.type = attr_speech;
2437 speech.u.speech = this_->speech;
2438 navigation_set_attr(this_->navigation, &speech);
2439 }
2440
2441 //DBG dbg(0, "Initializing graphics\n");
2442 //DBG dbg(0, "Setting Vehicle\n");
2443 navit_set_vehicle(this_, this_->vehicle);
2444 //DBG dbg(0, "Adding dynamic maps to mapset %p\n", this_->mapsets);
2445
2446 if (this_->mapsets)
2447 {
2448 struct mapset_handle *msh;
2449 ms = this_->mapsets->data;
2450 // **D** // this_->progress_cb=callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_);
2451 msh = mapset_open(ms);
2452 while (msh && (map = mapset_next(msh, 0)))
2453 {
2454 //pass new callback instance for each map in the mapset to make map callback list destruction work correctly
2455 // **D** // struct callback *pcb = callback_new_attr_1(callback_cast(navit_map_progress), attr_progress, this_);
2456 // **D** // map_add_callback(map, pcb);
2457 }
2458 mapset_close(msh);
2459
2460 if (this_->route)
2461 {
2462 if ((map = route_get_map(this_->route)))
2463 {
2464 struct attr map_a, map_name;
2465 map_a.type = attr_map;
2466 map_a.u.map = map;
2467 map_name.type = attr_name;
2468 map_name.u.str = "_ms_route";
2469 map_set_attr(map_a.u.map, &map_name);
2470 mapset_add_attr(ms, &map_a);
2471 }
2472
2473 if ((map = route_get_graph_map(this_->route)))
2474 {
2475 struct attr map_a, active, map_name;
2476 map_a.type = attr_map;
2477 map_a.u.map = map;
2478 active.type = attr_active;
2479 active.u.num = 0;
2480 map_name.type = attr_name;
2481 map_name.u.str = "_ms_route_graph";
2482 map_set_attr(map_a.u.map, &map_name);
2483 mapset_add_attr(ms, &map_a);
2484 map_set_attr(map, &active);
2485 }
2486 route_set_mapset(this_->route, ms);
2487 route_set_projection(this_->route, transform_get_projection(this_->trans));
2488 }
2489
2490 if (this_->tracking)
2491 {
2492 tracking_set_mapset(this_->tracking, ms);
2493 if (this_->route)
2494 {
2495 tracking_set_route(this_->tracking, this_->route);
2496 }
2497 }
2498
2499 if (this_->navigation)
2500 {
2501 if ((map = navigation_get_map(this_->navigation)))
2502 {
2503 struct attr map_a, active, map_name;
2504 map_a.type = attr_map;
2505 map_a.u.map = map;
2506 active.type = attr_active;
2507 active.u.num = 0;
2508 map_name.type = attr_name;
2509 map_name.u.str = "_ms_navigation";
2510 map_set_attr(map_a.u.map, &map_name);
2511 mapset_add_attr(ms, &map_a);
2512 map_set_attr(map, &active);
2513 }
2514 }
2515
2516 if (this_->tracking)
2517 {
2518 if ((map = tracking_get_map(this_->tracking)))
2519 {
2520 struct attr map_a, active, map_name;
2521 map_a.type = attr_map;
2522 map_a.u.map = map;
2523 active.type = attr_active;
2524 active.u.num = 0;
2525 map_name.type = attr_name;
2526 map_name.u.str = "_ms_tracking";
2527 map_set_attr(map_a.u.map, &map_name);
2528 mapset_add_attr(ms, &map_a);
2529 map_set_attr(map, &active);
2530 }
2531 }
2532 // *DISABLED* navit_add_former_destinations_from_file(this_);
2533 }
2534
2535 if (this_->route)
2536 {
2537 struct attr callback;
2538 this_->route_cb = callback_new_attr_1(callback_cast(navit_redraw_route), attr_route_status, this_);
2539 callback.type = attr_callback;
2540 callback.u.callback = this_->route_cb;
2541 route_add_attr(this_->route, &callback);
2542 }
2543
2207 if (this_->navigation) { 2544 if (this_->navigation)
2545 {
2208 if (this_->speech) { 2546 if (this_->speech)
2547 {
2209 this_->nav_speech_cb=callback_new_1(callback_cast(navit_speak), this_); 2548 this_->nav_speech_cb = callback_new_1(callback_cast(navit_speak), this_);
2210 navigation_register_callback(this_->navigation, attr_navigation_speech, this_->nav_speech_cb); 2549 navigation_register_callback(this_->navigation, attr_navigation_speech, this_->nav_speech_cb);
2211 } 2550 }
2551
2212 if (this_->route) 2552 if (this_->route)
2553 {
2213 navigation_set_route(this_->navigation, this_->route); 2554 navigation_set_route(this_->navigation, this_->route);
2214 } 2555 }
2556 }
2557
2215 dbg(0,"Setting Center\n"); 2558 dbg(0, "Setting Center\n");
2216 center_file = bookmarks_get_center_file(FALSE); 2559 center_file = bookmarks_get_center_file(FALSE);
2560 //dbg(0, "g0\n");
2217 bookmarks_set_center_from_file(this_->bookmarks, center_file); 2561 bookmarks_set_center_from_file(this_->bookmarks, center_file);
2218 g_free(center_file); 2562 g_free(center_file);
2219#if 0 2563#if 0
2220 if (this_->menubar) { 2564 if (this_->menubar)
2565 {
2221 men=menu_add(this_->menubar, "Data", menu_type_submenu, NULL); 2566 men=menu_add(this_->menubar, "Data", menu_type_submenu, NULL);
2222 if (men) { 2567 if (men)
2568 {
2223 navit_add_menu_windows_items(this_, men); 2569 navit_add_menu_windows_items(this_, men);
2224 } 2570 }
2225 } 2571 }
2226#endif 2572#endif
2227 global_navit=this_; 2573 global_navit = this_;
2228#if 0 2574#if 0
2229 navit_window_roadbook_new(this_); 2575 navit_window_roadbook_new(this_);
2230 navit_window_items_new(this_); 2576 navit_window_items_new(this_);
2231#endif 2577#endif
2232 2578
2579 //dbg(0, "g1\n");
2233 messagelist_init(this_->messages); 2580 //messagelist_init(this_->messages);
2234 2581
2582 //dbg(0, "g2\n");
2235 navit_set_cursors(this_); 2583 navit_set_cursors(this_);
2236 2584
2237 callback_list_call_attr_1(this_->attr_cbl, attr_navit, this_); 2585 callback_list_call_attr_1(this_->attr_cbl, attr_navit, this_);
2238 callback=(this_->ready == 2); 2586 callback = (this_->ready == 2);
2239 dbg(0,"pre this_->ready=%d\n",this_->ready); 2587 //DBG dbg(0, "pre this_->ready=%d\n", this_->ready);
2240 this_->ready|=1; 2588 this_->ready |= 1;
2241 dbg(0,"set this_->ready=%d\n",this_->ready); 2589 //DBG dbg(0, "set this_->ready=%d\n", this_->ready);
2242 //dbg(0,"ready=%d\n",this_->ready); 2590 ////DBG dbg(0,"ready=%d\n",this_->ready);
2243 if (this_->ready == 3) 2591 if (this_->ready == 3)
2244 { 2592 {
2245 //dbg(0,"navit_draw_async_003\n"); 2593 ////DBG dbg(0,"navit_draw_async_003\n");
2246 navit_draw_async(this_, 1); 2594 navit_draw_async(this_, 1);
2247 } 2595 }
2596
2248 if (callback) 2597 if (callback)
2598 {
2249 callback_list_call_attr_1(this_->attr_cbl, attr_graphics_ready, this_); 2599 callback_list_call_attr_1(this_->attr_cbl, attr_graphics_ready, this_);
2600 }
2250#if 0 2601#if 0
2251 routech_test(this_); 2602 routech_test(this_);
2252#endif 2603#endif
2253 //dbg(0,"1111111111\n"); 2604 //dbg(0, "1111111111\n");
2254} 2605}
2255 2606
2256void
2257navit_zoom_to_rect(struct navit *this_, struct coord_rect *r) 2607void navit_zoom_to_rect(struct navit *this_, struct coord_rect *r)
2258{ 2608{
2259 //dbg(0,"EEnter\n"); 2609 ////DBG dbg(0,"EEnter\n");
2260 struct coord c; 2610 struct coord c;
2261 int scale=16; 2611 int scale = 16;
2262 2612
2263 c.x=(r->rl.x+r->lu.x)/2; 2613 c.x = (r->rl.x + r->lu.x) / 2;
2264 c.y=(r->rl.y+r->lu.y)/2; 2614 c.y = (r->rl.y + r->lu.y) / 2;
2265 transform_set_center(this_->trans, &c); 2615 transform_set_center(this_->trans, &c);
2266 dbg(1,"%x,%x-%x,%x\n", r->rl.x,r->rl.y,r->lu.x,r->lu.y); 2616 // dbg(1, "%x,%x-%x,%x\n", r->rl.x, r->rl.y, r->lu.x, r->lu.y);
2267 while (scale < 1<<20) { 2617 while (scale < 1 << 20)
2618 {
2268 struct point p1,p2; 2619 struct point p1, p2;
2269 transform_set_scale(this_->trans, scale); 2620 transform_set_scale(this_->trans, scale);
2270 transform_setup_source_rect(this_->trans); 2621 transform_setup_source_rect(this_->trans);
2271 transform(this_->trans, transform_get_projection(this_->trans), &r->lu, &p1, 1, 0, 0, NULL); 2622 transform(this_->trans, transform_get_projection(this_->trans), &r->lu, &p1, 1, 0, 0, NULL);
2272 transform(this_->trans, transform_get_projection(this_->trans), &r->rl, &p2, 1, 0, 0, NULL); 2623 transform(this_->trans, transform_get_projection(this_->trans), &r->rl, &p2, 1, 0, 0, NULL);
2273 dbg(1,"%d,%d-%d,%d\n",p1.x,p1.y,p2.x,p2.y); 2624 // dbg(1, "%d,%d-%d,%d\n", p1.x, p1.y, p2.x, p2.y);
2274 if (p1.x < 0 || p2.x < 0 || p1.x > this_->w || p2.x > this_->w || 2625 if (p1.x < 0 || p2.x < 0 || p1.x > this_->w || p2.x > this_->w || p1.y < 0 || p2.y < 0 || p1.y > this_->h || p2.y > this_->h)
2275 p1.y < 0 || p2.y < 0 || p1.y > this_->h || p2.y > this_->h)
2276 scale*=2; 2626 scale *= 2;
2277 else 2627 else
2278 break; 2628 break;
2279 2629
2280 } 2630 }
2281 if (this_->ready == 3) 2631 if (this_->ready == 3)
2282 { 2632 {
2283 //dbg(0,"navit_draw_async_004\n"); 2633 ////DBG dbg(0,"navit_draw_async_004\n");
2284 navit_draw_async(this_,0); 2634 navit_draw_async(this_, 0);
2285 } 2635 }
2286} 2636}
2287 2637
2288void
2289navit_zoom_to_route(struct navit *this_, int orientation) 2638void navit_zoom_to_route(struct navit *this_, int orientation)
2290{ 2639{
2291 //dbg(0,"EEnter\n"); 2640 ////DBG dbg(0,"EEnter\n");
2292 struct map *map; 2641 struct map *map;
2293 struct map_rect *mr=NULL; 2642 struct map_rect *mr = NULL;
2294 struct item *item; 2643 struct item *item;
2295 struct coord c; 2644 struct coord c;
2296 struct coord_rect r; 2645 struct coord_rect r;
2297 int count=0; 2646 int count = 0;
2298 if (! this_->route) 2647 if (!this_->route)
2299 return; 2648 return;
2300 dbg(1,"enter\n"); 2649 // dbg(1, "enter\n");
2301 map=route_get_map(this_->route); 2650 map = route_get_map(this_->route);
2302 dbg(1,"map=%p\n",map); 2651 // dbg(1, "map=%p\n", map);
2303 if (map) 2652 if (map)
2304 mr=map_rect_new(map, NULL); 2653 mr = map_rect_new(map, NULL);
2305 dbg(1,"mr=%p\n",mr); 2654 // dbg(1, "mr=%p\n", mr);
2306 if (mr) { 2655 if (mr)
2656 {
2307 while ((item=map_rect_get_item(mr))) { 2657 while ((item = map_rect_get_item(mr)))
2658 {
2308 dbg(1,"item=%s\n", item_to_name(item->type)); 2659 // dbg(1, "item=%s\n", item_to_name(item->type));
2309 while (item_coord_get(item, &c, 1)) { 2660 while (item_coord_get(item, &c, 1))
2661 {
2310 dbg(1,"coord\n"); 2662 // dbg(1, "coord\n");
2311 if (!count) 2663 if (!count)
2312 r.lu=r.rl=c; 2664 r.lu = r.rl = c;
2313 else 2665 else
2314 coord_rect_extend(&r, &c); 2666 coord_rect_extend(&r, &c);
2315 count++; 2667 count++;
2316 } 2668 }
2317 } 2669 }
2318 map_rect_destroy(mr); 2670 map_rect_destroy(mr);
2319 } 2671 }
2320 if (! count) 2672 if (!count)
2321 return; 2673 return;
2322 if (orientation != -1) 2674 if (orientation != -1)
2323 transform_set_yaw(this_->trans, orientation); 2675 transform_set_yaw(this_->trans, orientation);
2324 navit_zoom_to_rect(this_, &r); 2676 navit_zoom_to_rect(this_, &r);
2325} 2677}
2326 2678
2327static void
2328navit_cmd_zoom_to_route(struct navit *this) 2679static void navit_cmd_zoom_to_route(struct navit *this)
2329{ 2680{
2330 //dbg(0,"EEnter\n"); 2681 ////DBG dbg(0,"EEnter\n");
2331 navit_zoom_to_route(this, 0); 2682 navit_zoom_to_route(this, 0);
2332} 2683}
2333
2334 2684
2335/** 2685/**
2336 * show point on map 2686 * show point on map
2337 * 2687 *
2338 * @param navit The navit instance 2688 * @param navit The navit instance
2339 * @param center The point where to center the map, including its projection 2689 * @param center The point where to center the map, including its projection
2340 * @returns nothing 2690 * @returns nothing
2341 */ 2691 */
2342void
2343navit_set_center(struct navit *this_, struct pcoord *center, int set_timeout) 2692void navit_set_center(struct navit *this_, struct pcoord *center, int set_timeout)
2344{ 2693{
2345 //dbg(0,"EEnter\n"); 2694 ////DBG dbg(0,"EEnter\n");
2346 struct coord *c=transform_center(this_->trans); 2695 struct coord *c = transform_center(this_->trans);
2347 struct coord c1,c2; 2696 struct coord c1, c2;
2348 enum projection pro = transform_get_projection(this_->trans); 2697 enum projection pro = transform_get_projection(this_->trans);
2349 if (pro != center->pro) { 2698 if (pro != center->pro)
2699 {
2350 c1.x = center->x; 2700 c1.x = center->x;
2351 c1.y = center->y; 2701 c1.y = center->y;
2352 transform_from_to(&c1, center->pro, &c2, pro); 2702 transform_from_to(&c1, center->pro, &c2, pro);
2353 } else { 2703 }
2704 else
2705 {
2354 c2.x = center->x; 2706 c2.x = center->x;
2355 c2.y = center->y; 2707 c2.y = center->y;
2356 } 2708 }
2357 *c=c2; 2709 *c = c2;
2358 if (set_timeout) 2710 if (set_timeout)
2711 {
2359 navit_set_timeout(this_); 2712 navit_set_timeout(this_);
2713 }
2360 if (this_->ready == 3) 2714 if (this_->ready == 3)
2715 {
2361 navit_draw(this_); 2716 navit_draw(this_);
2717 }
2362} 2718}
2363 2719
2364static void
2365navit_set_center_coord_screen(struct navit *this_, struct coord *c, struct point *p, int set_timeout) 2720static void navit_set_center_coord_screen(struct navit *this_, struct coord *c, struct point *p, int set_timeout)
2366{ 2721{
2367 //dbg(0,"EEnter\n"); 2722 ////DBG dbg(0,"EEnter\n");
2368 int width, height; 2723 int width, height;
2369 struct point po; 2724 struct point po;
2370 transform_set_center(this_->trans, c); 2725 transform_set_center(this_->trans, c);
2371 transform_get_size(this_->trans, &width, &height); 2726 transform_get_size(this_->trans, &width, &height);
2372 po.x=width/2; 2727 po.x = width / 2;
2373 po.y=height/2; 2728 po.y = height / 2;
2374 update_transformation(this_->trans, &po, p, NULL); 2729 update_transformation(this_->trans, &po, p, NULL);
2375 if (set_timeout) 2730 if (set_timeout)
2731 {
2376 navit_set_timeout(this_); 2732 navit_set_timeout(this_);
2733 }
2377} 2734}
2378 2735
2379/** 2736/**
2380 * Links all vehicles to a cursor depending on the current profile. 2737 * Links all vehicles to a cursor depending on the current profile.
2381 * 2738 *
2382 * @param this_ A navit instance 2739 * @param this_ A navit instance
2383 * @author Ralph Sennhauser (10/2009) 2740 * @author Ralph Sennhauser (10/2009)
2384 */ 2741 */
2385static void
2386navit_set_cursors(struct navit *this_) 2742void navit_set_cursors(struct navit *this_)
2387{ 2743{
2388 //dbg(0,"EEnter\n");
2389 struct attr name; 2744 struct attr name;
2390 struct navit_vehicle *nv; 2745 struct navit_vehicle *nv;
2391 struct cursor *c; 2746 struct cursor *c;
2392 GList *v; 2747 GList *v;
2393 2748
2749 //dbg(0, "Enter\n");
2750
2394 v=g_list_first(this_->vehicles); // GList of navit_vehicles 2751 v = g_list_first(this_->vehicles); // GList of navit_vehicles
2395 while (v) { 2752 while (v)
2753 {
2754 dbg(0, "* found vehicle *\n");
2396 nv=v->data; 2755 nv = v->data;
2397 if (vehicle_get_attr(nv->vehicle, attr_cursorname, &name, NULL)) { 2756 if (vehicle_get_attr(nv->vehicle, attr_cursorname, &name, NULL))
2757 {
2398 if (!strcmp(name.u.str,"none")) 2758 if (!strcmp(name.u.str, "none"))
2759 {
2399 c=NULL; 2760 c = NULL;
2761 }
2400 else 2762 else
2763 {
2401 c=layout_get_cursor(this_->layout_current, name.u.str); 2764 c = layout_get_cursor(this_->layout_current, name.u.str);
2765 }
2766 }
2402 } else 2767 else
2768 {
2403 c=layout_get_cursor(this_->layout_current, "default"); 2769 c = layout_get_cursor(this_->layout_current, "default");
2770 }
2404 vehicle_set_cursor(nv->vehicle, c, 0); 2771 vehicle_set_cursor(nv->vehicle, c, 0);
2405 v=g_list_next(v); 2772 v = g_list_next(v);
2406 } 2773 }
2407 return; 2774 return;
2408} 2775}
2409 2776
2410static int 2777void navit_remove_cursors(struct navit *this_)
2411navit_get_cursor_pnt(struct navit *this_, struct point *p, int keep_orientation, int *dir)
2412{ 2778{
2779 struct attr name;
2780 struct navit_vehicle *nv;
2781 struct cursor *c;
2782 GList *v;
2783
2413 //dbg(0,"EEnter\n"); 2784 //dbg(0, "Enter\n");
2785 name.type = attr_cursor;
2786
2787 v = g_list_first(this_->vehicles); // GList of navit_vehicles
2788 while (v)
2789 {
2790 dbg(0, "* found vehicle *\n");
2791 nv = v->data;
2792 vehicle_remove_attr(nv->vehicle, &name);
2793 v = g_list_next(v);
2794 }
2795 return;
2796}
2797
2798static int navit_get_cursor_pnt(struct navit *this_, struct point *p, int keep_orientation, int *dir)
2799{
2800 ////DBG dbg(0,"EEnter\n");
2414 int width, height; 2801 int width, height;
2415 struct navit_vehicle *nv=this_->vehicle; 2802 struct navit_vehicle *nv = this_->vehicle;
2416 2803
2417 float offset=this_->radius; // Cursor offset from the center of the screen (percent). 2804 float offset = this_->radius; // Cursor offset from the center of the screen (percent).
2418#if 0 /* Better improve track.c to get that issue resolved or make it configurable with being off the default, the jumping back to the center is a bit annoying */ 2805#if 0 /* Better improve track.c to get that issue resolved or make it configurable with being off the default, the jumping back to the center is a bit annoying */
2419 float min_offset = 0.; // Percent offset at min_offset_speed. 2806 float min_offset = 0.; // Percent offset at min_offset_speed.
2420 float max_offset = 30.; // Percent offset at max_offset_speed. 2807 float max_offset = 30.; // Percent offset at max_offset_speed.
2421 int min_offset_speed = 2; // Speed in km/h 2808 int min_offset_speed = 2; // Speed in km/h
2422 int max_offset_speed = 50; // Speed ini km/h 2809 int max_offset_speed = 50; // Speed ini km/h
2423 // Calculate cursor offset from the center of the screen, upon speed. 2810 // Calculate cursor offset from the center of the screen, upon speed.
2424 if (nv->speed <= min_offset_speed) { 2811 if (nv->speed <= min_offset_speed)
2425 offset = min_offset; 2812 {
2813 offset = min_offset;
2814 }
2426 } else if (nv->speed > max_offset_speed) { 2815 else if (nv->speed > max_offset_speed)
2427 offset = max_offset; 2816 {
2428 } else { 2817 offset = max_offset;
2818 }
2819 else
2820 {
2429 offset = (max_offset - min_offset) / (max_offset_speed - min_offset_speed) * (nv->speed - min_offset_speed); 2821 offset = (max_offset - min_offset) / (max_offset_speed - min_offset_speed) * (nv->speed - min_offset_speed);
2430 } 2822 }
2431#endif 2823#endif
2432 2824
2433 transform_get_size(this_->trans, &width, &height); 2825 transform_get_size(this_->trans, &width, &height);
2434 if (this_->orientation == -1 || keep_orientation) { 2826 if (this_->orientation == -1 || keep_orientation)
2827 {
2435 p->x=50*width/100; 2828 p->x = 50 * width / 100;
2436 p->y=(50 + offset)*height/100; 2829 p->y = (50 + offset) * height / 100;
2437 if (dir) 2830 if (dir)
2438 *dir=keep_orientation?this_->orientation:nv->dir; 2831 *dir = keep_orientation ? this_->orientation : nv->dir;
2439 } else { 2832 }
2833 else
2834 {
2440 int mdir; 2835 int mdir;
2441 if (this_->tracking && this_->tracking_flag) { 2836 if (this_->tracking && this_->tracking_flag)
2837 {
2442 mdir = tracking_get_angle(this_->tracking) - this_->orientation; 2838 mdir = tracking_get_angle(this_->tracking) - this_->orientation;
2839 }
2443 } else { 2840 else
2841 {
2444 mdir=nv->dir-this_->orientation; 2842 mdir = nv->dir - this_->orientation;
2445 } 2843 }
2446 2844
2447 p->x=(50 - offset*sin(M_PI*mdir/180.))*width/100; 2845 p->x = (50 - offset * sin(M_PI * mdir / 180.)) * width / 100;
2448 p->y=(50 + offset*cos(M_PI*mdir/180.))*height/100; 2846 p->y = (50 + offset * cos(M_PI * mdir / 180.)) * height / 100;
2449 if (dir) 2847 if (dir)
2450 *dir=this_->orientation; 2848 *dir = this_->orientation;
2451 } 2849 }
2452 return 1; 2850 return 1;
2453} 2851}
2454 2852
2455void
2456navit_set_center_cursor(struct navit *this_, int autozoom, int keep_orientation) 2853void navit_set_center_cursor(struct navit *this_, int autozoom, int keep_orientation)
2457{ 2854{
2458 //dbg(0,"EEnter\n"); 2855 ////DBG dbg(0,"EEnter\n");
2459 int dir; 2856 int dir;
2460 struct point pn; 2857 struct point pn;
2461 struct navit_vehicle *nv=this_->vehicle; 2858 struct navit_vehicle *nv = this_->vehicle;
2462 navit_get_cursor_pnt(this_, &pn, keep_orientation, &dir); 2859 navit_get_cursor_pnt(this_, &pn, keep_orientation, &dir);
2463 transform_set_yaw(this_->trans, dir); 2860 transform_set_yaw(this_->trans, dir);
2464 navit_set_center_coord_screen(this_, &nv->coord, &pn, 0); 2861 navit_set_center_coord_screen(this_, &nv->coord, &pn, 0);
2465 if (autozoom) 2862 if (autozoom)
2466 navit_autozoom(this_, &nv->coord, nv->speed, 0); 2863 navit_autozoom(this_, &nv->coord, nv->speed, 0);
2467} 2864}
2468 2865
2469static void
2470navit_set_center_cursor_draw(struct navit *this_) 2866static void navit_set_center_cursor_draw(struct navit *this_)
2471{ 2867{
2472 //dbg(0,"EEnter\n"); 2868 ////DBG dbg(0,"EEnter\n");
2473 navit_set_center_cursor(this_,1,0); 2869 navit_set_center_cursor(this_, 1, 0);
2474 if (this_->ready == 3) 2870 if (this_->ready == 3)
2475 { 2871 {
2476 //dbg(0,"navit_draw_async_005\n"); 2872 ////DBG dbg(0,"navit_draw_async_005\n");
2477 navit_draw_async(this_, 1); 2873 navit_draw_async(this_, 1);
2478 } 2874 }
2479} 2875}
2480 2876
2481static void
2482navit_cmd_set_center_cursor(struct navit *this_) 2877static void navit_cmd_set_center_cursor(struct navit *this_)
2483{ 2878{
2484 //dbg(0,"EEnter\n"); 2879 ////DBG dbg(0,"EEnter\n");
2485 navit_set_center_cursor_draw(this_); 2880 navit_set_center_cursor_draw(this_);
2486} 2881}
2487 2882
2488void
2489navit_set_center_screen(struct navit *this_, struct point *p, int set_timeout) 2883void navit_set_center_screen(struct navit *this_, struct point *p, int set_timeout)
2490{ 2884{
2491 //dbg(0,"EEnter\n"); 2885 ////DBG dbg(0,"EEnter\n");
2492 struct coord c; 2886 struct coord c;
2493 struct pcoord pc; 2887 struct pcoord pc;
2494 transform_reverse(this_->trans, p, &c); 2888 transform_reverse(this_->trans, p, &c);
2495 pc.x = c.x; 2889 pc.x = c.x;
2496 pc.y = c.y; 2890 pc.y = c.y;
2497 pc.pro = transform_get_projection(this_->trans); 2891 pc.pro = transform_get_projection(this_->trans);
2498 navit_set_center(this_, &pc, set_timeout); 2892 navit_set_center(this_, &pc, set_timeout);
2499} 2893}
2500 2894
2501#if 0 2895#if 0
2502 switch((*attrs)->type) { 2896switch((*attrs)->type)
2897{
2503 case attr_zoom: 2898 case attr_zoom:
2504 zoom=(*attrs)->u.num; 2899 zoom=(*attrs)->u.num;
2505 break; 2900 break;
2506 case attr_center: 2901 case attr_center:
2507 g=*((*attrs)->u.coord_geo); 2902 g=*((*attrs)->u.coord_geo);
2508 break; 2903 break;
2509#endif 2904#endif
2510 2905
2511static int
2512navit_set_attr_do(struct navit *this_, struct attr *attr, int init) 2906static int navit_set_attr_do(struct navit *this_, struct attr *attr, int init)
2513{ 2907{
2514 //dbg(0,"EEnter\n"); 2908 ////DBG dbg(0,"EEnter\n");
2515 int dir=0, orient_old=0, attr_updated=0; 2909 int dir = 0, orient_old = 0, attr_updated = 0;
2516 struct coord co; 2910 struct coord co;
2517 long zoom; 2911 long zoom;
2518 GList *l; 2912 GList *l;
2519 struct navit_vehicle *nv; 2913 struct navit_vehicle *nv;
2520 struct layout *lay; 2914 struct layout *lay;
2521 struct attr active; 2915 struct attr active;
2522 active.type=attr_active; 2916 active.type = attr_active;
2523 active.u.num=0; 2917 active.u.num = 0;
2524 2918
2525 switch (attr->type) { 2919 switch (attr->type)
2920 {
2526 case attr_autozoom: 2921 case attr_autozoom:
2527 attr_updated=(this_->autozoom_secs != attr->u.num); 2922 attr_updated = (this_->autozoom_secs != attr->u.num);
2528 this_->autozoom_secs = attr->u.num; 2923 this_->autozoom_secs = attr->u.num;
2529 break; 2924 break;
2530 case attr_autozoom_active: 2925 case attr_autozoom_active:
2531 attr_updated=(this_->autozoom_active != attr->u.num); 2926 attr_updated = (this_->autozoom_active != attr->u.num);
2532 this_->autozoom_active = attr->u.num; 2927 this_->autozoom_active = attr->u.num;
2533 break; 2928 break;
2534 case attr_center: 2929 case attr_center:
2535 transform_from_geo(transform_get_projection(this_->trans), attr->u.coord_geo, &co); 2930 transform_from_geo(transform_get_projection(this_->trans), attr->u.coord_geo, &co);
2536 dbg(1,"0x%x,0x%x\n",co.x,co.y); 2931 // dbg(1, "0x%x,0x%x\n", co.x, co.y);
2537 transform_set_center(this_->trans, &co); 2932 transform_set_center(this_->trans, &co);
2538 break; 2933 break;
2539 case attr_drag_bitmap: 2934 case attr_drag_bitmap:
2540 attr_updated=(this_->drag_bitmap != !!attr->u.num); 2935 attr_updated = (this_->drag_bitmap != !!attr->u.num);
2541 this_->drag_bitmap=!!attr->u.num; 2936 this_->drag_bitmap = !!attr->u.num;
2542 break; 2937 break;
2543 case attr_flags: 2938 case attr_flags:
2544 attr_updated=(this_->flags != attr->u.num); 2939 attr_updated = (this_->flags != attr->u.num);
2545 this_->flags=attr->u.num; 2940 this_->flags = attr->u.num;
2546 break; 2941 break;
2547 case attr_flags_graphics: 2942 case attr_flags_graphics:
2548 attr_updated=(this_->graphics_flags != attr->u.num); 2943 attr_updated = (this_->graphics_flags != attr->u.num);
2549 this_->graphics_flags=attr->u.num; 2944 this_->graphics_flags = attr->u.num;
2550 break; 2945 break;
2551 case attr_follow: 2946 case attr_follow:
2552 if (!this_->vehicle) 2947 if (!this_->vehicle)
2553 return 0; 2948 return 0;
2554 attr_updated=(this_->vehicle->follow_curr != attr->u.num); 2949 attr_updated = (this_->vehicle->follow_curr != attr->u.num);
2555 this_->vehicle->follow_curr = attr->u.num; 2950 this_->vehicle->follow_curr = attr->u.num;
2556 break; 2951 break;
2557 case attr_layout: 2952 case attr_layout:
2558 if(this_->layout_current!=attr->u.layout) { 2953 if (this_->layout_current != attr->u.layout)
2954 {
2559 this_->layout_current=attr->u.layout; 2955 this_->layout_current = attr->u.layout;
2560 graphics_font_destroy_all(this_->gra); 2956 graphics_font_destroy_all(this_->gra);
2561 navit_set_cursors(this_); 2957 navit_set_cursors(this_);
2562 if (this_->ready == 3)
2563 navit_draw(this_);
2564 attr_updated=1;
2565 }
2566 break;
2567 case attr_layout_name:
2568 l=this_->layouts;
2569 while (l) {
2570 lay=l->data;
2571 if (!strcmp(lay->name,attr->u.str)) {
2572 struct attr attr;
2573 attr.type=attr_layout;
2574 attr.u.layout=lay;
2575 return navit_set_attr_do(this_, &attr, init);
2576 }
2577 l=g_list_next(l);
2578 }
2579 return 0;
2580 case attr_map_border:
2581 if (this_->border != attr->u.num) {
2582 this_->border=attr->u.num;
2583 attr_updated=1;
2584 }
2585 break;
2586 case attr_orientation:
2587 orient_old=this_->orientation;
2588 this_->orientation=attr->u.num;
2589 if (!init) {
2590 if (this_->orientation != -1) {
2591 dir = this_->orientation;
2592 } else {
2593 if (this_->vehicle) {
2594 dir = this_->vehicle->dir;
2595 }
2596 }
2597 transform_set_yaw(this_->trans, dir);
2598 if (orient_old != this_->orientation) {
2599#if 0
2600 if (this_->ready == 3) 2958 if (this_->ready == 3)
2601 navit_draw(this_); 2959 navit_draw(this_);
2960 attr_updated = 1;
2961 }
2962 break;
2963 case attr_layout_name:
2964 l = this_->layouts;
2965 while (l)
2966 {
2967 lay = l->data;
2968 if (!strcmp(lay->name, attr->u.str))
2969 {
2970 struct attr attr;
2971 attr.type = attr_layout;
2972 attr.u.layout = lay;
2973 return navit_set_attr_do(this_, &attr, init);
2974 }
2975 l = g_list_next(l);
2976 }
2977 return 0;
2978 case attr_map_border:
2979 if (this_->border != attr->u.num)
2980 {
2981 this_->border = attr->u.num;
2982 attr_updated = 1;
2983 }
2984 break;
2985 case attr_orientation:
2986 orient_old = this_->orientation;
2987 this_->orientation = attr->u.num;
2988 if (!init)
2989 {
2990 if (this_->orientation != -1)
2991 {
2992 dir = this_->orientation;
2993 }
2994 else
2995 {
2996 if (this_->vehicle)
2997 {
2998 dir = this_->vehicle->dir;
2999 }
3000 }
3001 transform_set_yaw(this_->trans, dir);
3002 if (orient_old != this_->orientation)
3003 {
3004#if 0
3005 if (this_->ready == 3)
3006 navit_draw(this_);
2602#endif 3007#endif
2603 attr_updated=1;
2604 }
2605 }
2606 break;
2607 case attr_osd_configuration:
2608 dbg(0,"setting osd_configuration to %d (was %d)\n", attr->u.num, this_->osd_configuration);
2609 attr_updated=(this_->osd_configuration != attr->u.num);
2610 this_->osd_configuration=attr->u.num;
2611 break;
2612 case attr_pitch:
2613 attr_updated=(this_->pitch != attr->u.num);
2614 this_->pitch=attr->u.num;
2615 transform_set_pitch(this_->trans, this_->pitch);
2616 if (!init && attr_updated && this_->ready == 3)
2617 navit_draw(this_);
2618 break;
2619 case attr_projection:
2620 if(this_->trans && transform_get_projection(this_->trans) != attr->u.projection) {
2621 navit_projection_set(this_, attr->u.projection, !init);
2622 attr_updated=1;
2623 }
2624 break;
2625 case attr_radius:
2626 attr_updated=(this_->radius != attr->u.num);
2627 this_->radius=attr->u.num;
2628 break;
2629 case attr_recent_dest:
2630 attr_updated=(this_->recentdest_count != attr->u.num);
2631 this_->recentdest_count=attr->u.num;
2632 break;
2633 case attr_speech:
2634 if(this_->speech && this_->speech != attr->u.speech) {
2635 attr_updated=1;
2636 this_->speech = attr->u.speech;
2637 }
2638 break;
2639 case attr_timeout:
2640 attr_updated=(this_->center_timeout != attr->u.num);
2641 this_->center_timeout = attr->u.num;
2642 break;
2643 case attr_tracking:
2644 attr_updated=(this_->tracking_flag != !!attr->u.num);
2645 this_->tracking_flag=!!attr->u.num;
2646 break;
2647 case attr_transformation:
2648 this_->trans=attr->u.transformation;
2649 break;
2650 case attr_use_mousewheel:
2651 attr_updated=(this_->use_mousewheel != !!attr->u.num);
2652 this_->use_mousewheel=!!attr->u.num;
2653 break;
2654 case attr_vehicle:
2655 l=this_->vehicles;
2656 while(l) {
2657 nv=l->data;
2658 if (nv->vehicle == attr->u.vehicle) {
2659 if (!this_->vehicle || this_->vehicle->vehicle != attr->u.vehicle) {
2660 if (this_->vehicle)
2661 vehicle_set_attr(this_->vehicle->vehicle, &active);
2662 active.u.num=1;
2663 vehicle_set_attr(nv->vehicle, &active);
2664 attr_updated=1; 3008 attr_updated = 1;
2665 } 3009 }
3010 }
3011 break;
3012 case attr_osd_configuration:
3013 //DBG dbg(0, "setting osd_configuration to %d (was %d)\n", attr->u.num, this_->osd_configuration);
3014 attr_updated = (this_->osd_configuration != attr->u.num);
3015 this_->osd_configuration = attr->u.num;
3016 break;
3017 case attr_pitch:
3018 attr_updated = (this_->pitch != attr->u.num);
3019 this_->pitch = attr->u.num;
3020 transform_set_pitch(this_->trans, this_->pitch);
3021 if (!init && attr_updated && this_->ready == 3)
3022 navit_draw(this_);
3023 break;
3024 case attr_projection:
3025 if (this_->trans && transform_get_projection(this_->trans) != attr->u.projection)
3026 {
3027 navit_projection_set(this_, attr->u.projection, !init);
3028 attr_updated = 1;
3029 }
3030 break;
3031 case attr_radius:
3032 attr_updated = (this_->radius != attr->u.num);
3033 this_->radius = attr->u.num;
3034 break;
3035 case attr_recent_dest:
3036 attr_updated = (this_->recentdest_count != attr->u.num);
3037 this_->recentdest_count = attr->u.num;
3038 break;
3039 case attr_speech:
3040 if (this_->speech && this_->speech != attr->u.speech)
3041 {
3042 attr_updated = 1;
3043 this_->speech = attr->u.speech;
3044 }
3045 break;
3046 case attr_timeout:
3047 attr_updated = (this_->center_timeout != attr->u.num);
3048 this_->center_timeout = attr->u.num;
3049 break;
3050 case attr_tracking:
3051 attr_updated = (this_->tracking_flag != !!attr->u.num);
3052 this_->tracking_flag = !!attr->u.num;
3053 break;
3054 case attr_transformation:
3055 this_->trans = attr->u.transformation;
3056 break;
3057 case attr_use_mousewheel:
3058 attr_updated = (this_->use_mousewheel != !!attr->u.num);
3059 this_->use_mousewheel = !!attr->u.num;
3060 break;
3061 case attr_vehicle:
3062 l = this_->vehicles;
3063 while (l)
3064 {
3065 nv = l->data;
3066 if (nv->vehicle == attr->u.vehicle)
3067 {
3068 if (!this_->vehicle || this_->vehicle->vehicle != attr->u.vehicle)
3069 {
3070 if (this_->vehicle)
3071 vehicle_set_attr(this_->vehicle->vehicle, &active);
3072 active.u.num = 1;
3073 vehicle_set_attr(nv->vehicle, &active);
3074 attr_updated = 1;
3075 }
2666 navit_set_vehicle(this_, nv); 3076 navit_set_vehicle(this_, nv);
2667 } 3077 }
2668 l=g_list_next(l); 3078 l = g_list_next(l);
2669 } 3079 }
2670 break; 3080 break;
2671 case attr_zoom: 3081 case attr_zoom:
2672 zoom=transform_get_scale(this_->trans); 3082 zoom = transform_get_scale(this_->trans);
2673 attr_updated=(zoom != attr->u.num); 3083 attr_updated = (zoom != attr->u.num);
2674 transform_set_scale(this_->trans, attr->u.num); 3084 transform_set_scale(this_->trans, attr->u.num);
2675 if (attr_updated && !init) 3085 if (attr_updated && !init)
2676 navit_draw(this_); 3086 navit_draw(this_);
2677 break; 3087 break;
2678 case attr_zoom_min: 3088 case attr_zoom_min:
2679 attr_updated=(attr->u.num != this_->zoom_min); 3089 attr_updated = (attr->u.num != this_->zoom_min);
2680 this_->zoom_min=attr->u.num; 3090 this_->zoom_min = attr->u.num;
2681 break; 3091 break;
2682 case attr_zoom_max: 3092 case attr_zoom_max:
2683 attr_updated=(attr->u.num != this_->zoom_max); 3093 attr_updated = (attr->u.num != this_->zoom_max);
2684 this_->zoom_max=attr->u.num; 3094 this_->zoom_max = attr->u.num;
2685 break; 3095 break;
2686 case attr_message: 3096 case attr_message:
2687 navit_add_message(this_, attr->u.str); 3097 //navit_add_message(this_, attr->u.str);
2688 break; 3098 break;
2689 case attr_follow_cursor: 3099 case attr_follow_cursor:
2690 attr_updated=(this_->follow_cursor != !!attr->u.num); 3100 attr_updated = (this_->follow_cursor != !!attr->u.num);
2691 this_->follow_cursor=!!attr->u.num; 3101 this_->follow_cursor = !!attr->u.num;
2692 break; 3102 break;
2693 case attr_imperial: 3103 case attr_imperial:
2694 attr_updated=(this_->imperial != attr->u.num); 3104 attr_updated = (this_->imperial != attr->u.num);
2695 this_->imperial=attr->u.num; 3105 this_->imperial = attr->u.num;
2696 break; 3106 break;
2697 default: 3107 default:
2698 return 0; 3108 return 0;
2699 } 3109 }
2700 if (attr_updated && !init) { 3110 if (attr_updated && !init)
3111 {
2701 callback_list_call_attr_2(this_->attr_cbl, attr->type, this_, attr); 3112 callback_list_call_attr_2(this_->attr_cbl, attr->type, this_, attr);
2702 if (attr->type == attr_osd_configuration) 3113 if (attr->type == attr_osd_configuration)
2703 graphics_draw_mode(this_->gra, draw_mode_end); 3114 graphics_draw_mode(this_->gra, draw_mode_end);
2704 } 3115 }
2705 return 1; 3116 return 1;
2706} 3117}
2707 3118
2708int
2709navit_set_attr(struct navit *this_, struct attr *attr) 3119int navit_set_attr(struct navit *this_, struct attr *attr)
2710{ 3120{
2711 //dbg(0,"EEnter\n"); 3121 ////DBG dbg(0,"EEnter\n");
2712 return navit_set_attr_do(this_, attr, 0); 3122 return navit_set_attr_do(this_, attr, 0);
2713} 3123}
2714 3124
2715int
2716navit_get_attr(struct navit *this_, enum attr_type type, struct attr *attr, struct attr_iter *iter) 3125int navit_get_attr(struct navit *this_, enum attr_type type, struct attr *attr, struct attr_iter *iter)
2717{ 3126{
2718 //dbg(0,"EEnter\n"); 3127 ////DBG dbg(0,"EEnter\n");
2719 struct message *msg; 3128 struct message *msg;
2720 int len,offset; 3129 int len, offset;
2721 int ret=1; 3130 int ret = 1;
2722 3131
2723 switch (type) { 3132 switch (type)
3133 {
2724 case attr_message: 3134 case attr_message:
2725 msg = navit_get_messages(this_);
2726
2727 if (!msg) {
2728 return 0; 3135 return 0;
3136 /*
3137 msg = navit_get_messages(this_);
3138
3139 if (!msg)
3140 {
3141 return 0;
2729 } 3142 }
2730 3143
2731 len = 0; 3144 len = 0;
2732 while (msg) { 3145 while (msg)
3146 {
2733 len += strlen(msg->text) + 1; 3147 len += strlen(msg->text) + 1;
2734 msg = msg->next; 3148 msg = msg->next;
2735 } 3149 }
2736 attr->u.str = g_malloc(len + 1); 3150 attr->u.str = g_malloc(len + 1);
2737 3151
2738 msg = navit_get_messages(this_); 3152 msg = navit_get_messages(this_);
2739 offset = 0; 3153 offset = 0;
2740 while (msg) { 3154 while (msg)
3155 {
2741 g_stpcpy((attr->u.str + offset), msg->text); 3156 g_stpcpy((attr->u.str + offset), msg->text);
2742 offset += strlen(msg->text); 3157 offset += strlen(msg->text);
2743 attr->u.str[offset] = '\n'; 3158 attr->u.str[offset] = '\n';
2744 offset++; 3159 offset++;
2745 3160
2746 msg = msg->next; 3161 msg = msg->next;
2747 } 3162 }
2748 3163
2749 attr->u.str[len] = '\0'; 3164 attr->u.str[len] = '\0';
3165 */
2750 break; 3166 break;
2751 case attr_imperial: 3167 case attr_imperial:
2752 attr->u.num=this_->imperial; 3168 attr->u.num = this_->imperial;
2753 break; 3169 break;
2754 case attr_bookmark_map: 3170 case attr_bookmark_map:
2755 attr->u.map=bookmarks_get_map(this_->bookmarks); 3171 attr->u.map = bookmarks_get_map(this_->bookmarks);
2756 break; 3172 break;
2757 case attr_bookmarks: 3173 case attr_bookmarks:
2758 attr->u.bookmarks=this_->bookmarks; 3174 attr->u.bookmarks = this_->bookmarks;
2759 break; 3175 break;
2760 case attr_callback_list: 3176 case attr_callback_list:
2761 attr->u.callback_list=this_->attr_cbl; 3177 attr->u.callback_list = this_->attr_cbl;
2762 break; 3178 break;
2763 case attr_destination: 3179 case attr_destination:
2764 if (! this_->destination_valid) 3180 if (!this_->destination_valid)
3181 return 0;
3182 attr->u.pcoord = &this_->destination;
3183 break;
3184 case attr_displaylist:
3185 attr->u.displaylist = this_->displaylist;
3186 return (attr->u.displaylist != NULL);
3187 case attr_follow:
3188 if (!this_->vehicle)
3189 return 0;
3190 attr->u.num = this_->vehicle->follow_curr;
3191 break;
3192 case attr_former_destination_map:
3193 attr->u.map = this_->former_destination;
3194 break;
3195 case attr_graphics:
3196 attr->u.graphics = this_->gra;
3197 ret = (attr->u.graphics != NULL);
3198 break;
3199 case attr_gui:
3200 attr->u.gui = this_->gui;
3201 ret = (attr->u.gui != NULL);
3202 break;
3203 case attr_layout:
3204 if (iter)
3205 {
3206 if (iter->u.list)
3207 {
3208 iter->u.list = g_list_next(iter->u.list);
3209 }
3210 else
3211 {
3212 iter->u.list = this_->layouts;
3213 }
3214 if (!iter->u.list)
3215 {
3216 return 0;
3217 }
3218 attr->u.layout = (struct layout *) iter->u.list->data;
3219 }
3220 else
3221 {
3222 attr->u.layout = this_->layout_current;
3223 }
3224 break;
3225 case attr_map:
3226 if (iter && this_->mapsets)
3227 {
3228 if (!iter->u.mapset_handle)
3229 {
3230 iter->u.mapset_handle = mapset_open((struct mapset *) this_->mapsets->data);
3231 }
3232 attr->u.map = mapset_next(iter->u.mapset_handle, 0);
3233 if (!attr->u.map)
3234 {
3235 mapset_close(iter->u.mapset_handle);
3236 return 0;
3237 }
3238 }
3239 else
3240 {
3241 return 0;
3242 }
3243 break;
3244 case attr_mapset:
3245 attr->u.mapset = this_->mapsets->data;
3246 ret = (attr->u.mapset != NULL);
3247 break;
3248 case attr_navigation:
3249 attr->u.navigation = this_->navigation;
3250 break;
3251 case attr_orientation:
3252 attr->u.num = this_->orientation;
3253 break;
3254 case attr_osd_configuration:
3255 attr->u.num = this_->osd_configuration;
3256 break;
3257 case attr_pitch:
3258 attr->u.num = transform_get_pitch(this_->trans);
3259 break;
3260 case attr_projection:
3261 if (this_->trans)
3262 {
3263 attr->u.num = transform_get_projection(this_->trans);
3264 }
3265 else
3266 {
3267 return 0;
3268 }
3269 break;
3270 case attr_route:
3271 attr->u.route = this_->route;
3272 break;
3273 case attr_speech:
3274 attr->u.speech = this_->speech;
3275 break;
3276 case attr_tracking:
3277 attr->u.num = this_->tracking_flag;
3278 break;
3279 case attr_trackingo:
3280 attr->u.tracking = this_->tracking;
3281 break;
3282 case attr_transformation:
3283 attr->u.transformation = this_->trans;
3284 break;
3285 case attr_vehicle:
3286 if (iter)
3287 {
3288 if (iter->u.list)
3289 {
3290 iter->u.list = g_list_next(iter->u.list);
3291 }
3292 else
3293 {
3294 iter->u.list = this_->vehicles;
3295 }
3296 if (!iter->u.list)
3297 return 0;
3298 attr->u.vehicle = ((struct navit_vehicle*) iter->u.list->data)->vehicle;
3299 }
3300 else
3301 {
3302 if (this_->vehicle)
3303 {
3304 attr->u.vehicle = this_->vehicle->vehicle;
3305 }
3306 else
3307 {
3308 return 0;
3309 }
3310 }
3311 break;
3312 case attr_vehicleprofile:
3313 attr->u.vehicleprofile = this_->vehicleprofile;
3314 break;
3315 case attr_zoom:
3316 attr->u.num = transform_get_scale(this_->trans);
3317 break;
3318 case attr_autozoom_active:
3319 attr->u.num = this_->autozoom_active;
3320 break;
3321 case attr_follow_cursor:
3322 attr->u.num = this_->follow_cursor;
3323 break;
3324 default:
2765 return 0; 3325 return 0;
2766 attr->u.pcoord=&this_->destination;
2767 break;
2768 case attr_displaylist:
2769 attr->u.displaylist=this_->displaylist;
2770 return (attr->u.displaylist != NULL);
2771 case attr_follow:
2772 if (!this_->vehicle)
2773 return 0;
2774 attr->u.num=this_->vehicle->follow_curr;
2775 break;
2776 case attr_former_destination_map:
2777 attr->u.map=this_->former_destination;
2778 break;
2779 case attr_graphics:
2780 attr->u.graphics=this_->gra;
2781 ret=(attr->u.graphics != NULL);
2782 break;
2783 case attr_gui:
2784 attr->u.gui=this_->gui;
2785 ret=(attr->u.gui != NULL);
2786 break;
2787 case attr_layout:
2788 if (iter)
2789 {
2790 if (iter->u.list)
2791 {
2792 iter->u.list=g_list_next(iter->u.list);
2793 }
2794 else
2795 {
2796 iter->u.list=this_->layouts;
2797 }
2798 if (!iter->u.list)
2799 {
2800 return 0;
2801 }
2802 attr->u.layout=(struct layout *)iter->u.list->data;
2803 } 3326 }
2804 else
2805 {
2806 attr->u.layout=this_->layout_current;
2807 }
2808 break;
2809 case attr_map:
2810 if (iter && this_->mapsets) {
2811 if (!iter->u.mapset_handle) {
2812 iter->u.mapset_handle=mapset_open((struct mapset *)this_->mapsets->data);
2813 }
2814 attr->u.map=mapset_next(iter->u.mapset_handle, 0);
2815 if(!attr->u.map) {
2816 mapset_close(iter->u.mapset_handle);
2817 return 0;
2818 }
2819 } else {
2820 return 0;
2821 }
2822 break;
2823 case attr_mapset:
2824 attr->u.mapset=this_->mapsets->data;
2825 ret=(attr->u.mapset != NULL);
2826 break;
2827 case attr_navigation:
2828 attr->u.navigation=this_->navigation;
2829 break;
2830 case attr_orientation:
2831 attr->u.num=this_->orientation;
2832 break;
2833 case attr_osd_configuration:
2834 attr->u.num=this_->osd_configuration;
2835 break;
2836 case attr_pitch:
2837 attr->u.num=transform_get_pitch(this_->trans);
2838 break;
2839 case attr_projection:
2840 if(this_->trans) {
2841 attr->u.num=transform_get_projection(this_->trans);
2842 } else {
2843 return 0;
2844 }
2845 break;
2846 case attr_route:
2847 attr->u.route=this_->route;
2848 break;
2849 case attr_speech:
2850 attr->u.speech=this_->speech;
2851 break;
2852 case attr_tracking:
2853 attr->u.num=this_->tracking_flag;
2854 break;
2855 case attr_trackingo:
2856 attr->u.tracking=this_->tracking;
2857 break;
2858 case attr_transformation:
2859 attr->u.transformation=this_->trans;
2860 break;
2861 case attr_vehicle:
2862 if(iter) {
2863 if(iter->u.list) {
2864 iter->u.list=g_list_next(iter->u.list);
2865 } else {
2866 iter->u.list=this_->vehicles;
2867 }
2868 if(!iter->u.list)
2869 return 0;
2870 attr->u.vehicle=((struct navit_vehicle*)iter->u.list->data)->vehicle;
2871 } else {
2872 if(this_->vehicle) {
2873 attr->u.vehicle=this_->vehicle->vehicle;
2874 } else {
2875 return 0;
2876 }
2877 }
2878 break;
2879 case attr_vehicleprofile:
2880 attr->u.vehicleprofile=this_->vehicleprofile;
2881 break;
2882 case attr_zoom:
2883 attr->u.num=transform_get_scale(this_->trans);
2884 break;
2885 case attr_autozoom_active:
2886 attr->u.num=this_->autozoom_active;
2887 break;
2888 case attr_follow_cursor:
2889 attr->u.num=this_->follow_cursor;
2890 break;
2891 default:
2892 return 0;
2893 }
2894 attr->type=type; 3327 attr->type = type;
2895 return ret; 3328 return ret;
2896} 3329}
2897 3330
2898static int
2899navit_add_log(struct navit *this_, struct log *log) 3331static int navit_add_log(struct navit *this_, struct log *log)
2900{ 3332{
2901 struct attr type_attr; 3333 struct attr type_attr;
2902 if (!log_get_attr(log, attr_type, &type_attr, NULL)) 3334 if (!log_get_attr(log, attr_type, &type_attr, NULL))
2903 return 0; 3335 return 0;
2904 if (!strcmp(type_attr.u.str, "textfile_debug")) { 3336 if (!strcmp(type_attr.u.str, "textfile_debug"))
3337 {
2905 char *header = "type=track_tracked\n"; 3338 char *header = "type=track_tracked\n";
2906 if (this_->textfile_debug_log) 3339 if (this_->textfile_debug_log)
2907 return 0; 3340 return 0;
2908 log_set_header(log, header, strlen(header)); 3341 log_set_header(log, header, strlen(header));
2909 this_->textfile_debug_log=log; 3342 this_->textfile_debug_log = log;
2910 return 1; 3343 return 1;
2911 } 3344 }
2912 return 0; 3345 return 0;
2913} 3346}
2914 3347
2915static int
2916navit_add_layout(struct navit *this_, struct layout *layout) 3348static int navit_add_layout(struct navit *this_, struct layout *layout)
2917{ 3349{
2918 //dbg(0,"EEnter\n"); 3350 ////DBG dbg(0,"EEnter\n");
2919 struct attr active; 3351 struct attr active;
2920 this_->layouts = g_list_append(this_->layouts, layout); 3352 this_->layouts = g_list_append(this_->layouts, layout);
2921 layout_get_attr(layout, attr_active, &active, NULL); 3353 layout_get_attr(layout, attr_active, &active, NULL);
2922 if(active.u.num || !this_->layout_current) { 3354 if (active.u.num || !this_->layout_current)
3355 {
2923 this_->layout_current=layout; 3356 this_->layout_current = layout;
2924 return 1; 3357 return 1;
2925 } 3358 }
2926 return 0; 3359 return 0;
2927} 3360}
2928 3361
2929int
2930navit_add_attr(struct navit *this_, struct attr *attr) 3362int navit_add_attr(struct navit *this_, struct attr *attr)
2931{ 3363{
2932 //dbg(0,"EEnter\n"); 3364 ////DBG dbg(0,"EEnter\n");
2933 3365
2934 int ret=1; 3366 int ret = 1;
2935 switch (attr->type) { 3367 switch (attr->type)
3368 {
2936 case attr_callback: 3369 case attr_callback:
2937 navit_add_callback(this_, attr->u.callback); 3370 navit_add_callback(this_, attr->u.callback);
2938 break; 3371 break;
2939 case attr_log: 3372 case attr_log:
2940 ret=navit_add_log(this_, attr->u.log); 3373 ret = navit_add_log(this_, attr->u.log);
2941 break; 3374 break;
2942 case attr_gui: 3375 case attr_gui:
2943 ret=navit_set_gui(this_, attr->u.gui); 3376 ret = navit_set_gui(this_, attr->u.gui);
2944 break; 3377 break;
2945 case attr_graphics: 3378 case attr_graphics:
2946 ret=navit_set_graphics(this_, attr->u.graphics); 3379 ret = navit_set_graphics(this_, attr->u.graphics);
2947 break; 3380 break;
2948 case attr_layout: 3381 case attr_layout:
2949 ret=navit_add_layout(this_, attr->u.layout); 3382 ret = navit_add_layout(this_, attr->u.layout);
2950 break; 3383 break;
2951 case attr_route: 3384 case attr_route:
2952 this_->route=attr->u.route; 3385 this_->route = attr->u.route;
2953 break; 3386 break;
2954 case attr_mapset: 3387 case attr_mapset:
2955 this_->mapsets = g_list_append(this_->mapsets, attr->u.mapset); 3388 this_->mapsets = g_list_append(this_->mapsets, attr->u.mapset);
2956 break; 3389 break;
2957 case attr_navigation: 3390 case attr_navigation:
2958 this_->navigation=attr->u.navigation; 3391 this_->navigation = attr->u.navigation;
2959 break; 3392 break;
2960 case attr_recent_dest: 3393 case attr_recent_dest:
2961 this_->recentdest_count = attr->u.num; 3394 this_->recentdest_count = attr->u.num;
2962 break; 3395 break;
2963 case attr_speech: 3396 case attr_speech:
2964 this_->speech=attr->u.speech; 3397 this_->speech = attr->u.speech;
2965 break; 3398 break;
2966 case attr_tracking: 3399 case attr_tracking:
2967 this_->tracking=attr->u.tracking; 3400 this_->tracking = attr->u.tracking;
2968 break; 3401 break;
2969 case attr_vehicle: 3402 case attr_vehicle:
2970 ret=navit_add_vehicle(this_, attr->u.vehicle); 3403 ret = navit_add_vehicle(this_, attr->u.vehicle);
2971 break; 3404 break;
2972 case attr_vehicleprofile: 3405 case attr_vehicleprofile:
2973 this_->vehicleprofiles=g_list_prepend(this_->vehicleprofiles, attr->u.vehicleprofile); 3406 this_->vehicleprofiles = g_list_prepend(this_->vehicleprofiles, attr->u.vehicleprofile);
2974 break; 3407 break;
2975 case attr_autozoom_min: 3408 case attr_autozoom_min:
2976 this_->autozoom_min = attr->u.num; 3409 this_->autozoom_min = attr->u.num;
2977 break; 3410 break;
2978 default: 3411 default:
2979 return 0; 3412 return 0;
2980 } 3413 }
2981 callback_list_call_attr_2(this_->attr_cbl, attr->type, this_, attr); 3414 callback_list_call_attr_2(this_->attr_cbl, attr->type, this_, attr);
2982 return ret; 3415 return ret;
2983} 3416}
2984 3417
2985int
2986navit_remove_attr(struct navit *this_, struct attr *attr) 3418int navit_remove_attr(struct navit *this_, struct attr *attr)
2987{ 3419{
2988 int ret=1; 3420 int ret = 1;
2989 switch (attr->type) { 3421 switch (attr->type)
3422 {
2990 case attr_callback: 3423 case attr_callback:
2991 navit_remove_callback(this_, attr->u.callback); 3424 navit_remove_callback(this_, attr->u.callback);
2992 break; 3425 break;
2993 default: 3426 default:
2994 return 0; 3427 return 0;
2995 } 3428 }
2996 return ret; 3429 return ret;
2997} 3430}
2998 3431
2999struct attr_iter * 3432struct attr_iter *
3000navit_attr_iter_new(void) 3433navit_attr_iter_new(void)
3001{ 3434{
3002 return g_new0(struct attr_iter, 1); 3435return g_new0(struct attr_iter, 1);
3003} 3436}
3004 3437
3005void
3006navit_attr_iter_destroy(struct attr_iter *iter) 3438void navit_attr_iter_destroy(struct attr_iter *iter)
3007{ 3439{
3008 g_free(iter); 3440 g_free(iter);
3009} 3441}
3010 3442
3011void
3012navit_add_callback(struct navit *this_, struct callback *cb) 3443void navit_add_callback(struct navit *this_, struct callback *cb)
3013{ 3444{
3014 //dbg(0,"EEnter\n"); 3445 ////DBG dbg(0,"EEnter\n");
3015 3446
3016 callback_list_add(this_->attr_cbl, cb); 3447 callback_list_add(this_->attr_cbl, cb);
3017} 3448}
3018 3449
3019void
3020navit_remove_callback(struct navit *this_, struct callback *cb) 3450void navit_remove_callback(struct navit *this_, struct callback *cb)
3021{ 3451{
3022 //dbg(0,"EEnter\n"); 3452 ////DBG dbg(0,"EEnter\n");
3023 3453
3024 callback_list_remove(this_->attr_cbl, cb); 3454 callback_list_remove(this_->attr_cbl, cb);
3025} 3455}
3026 3456
3027/** 3457/**
3029 * 3459 *
3030 * @param navit The navit instance 3460 * @param navit The navit instance
3031 * @returns nothing 3461 * @returns nothing
3032 */ 3462 */
3033 3463
3034static void
3035navit_vehicle_draw(struct navit *this_, struct navit_vehicle *nv, struct point *pnt) 3464static void navit_vehicle_draw(struct navit *this_, struct navit_vehicle *nv, struct point *pnt)
3036{ 3465{
3037 //dbg(0,"EEnter\n"); 3466 ////DBG dbg(0,"EEnter\n");
3038 3467
3039 struct point cursor_pnt; 3468 struct point cursor_pnt;
3040 enum projection pro; 3469 enum projection pro;
3041 3470
3042 if (this_->blocked) 3471 if (this_->blocked)
3043 return; 3472 return;
3044 if (pnt) 3473 if (pnt)
3045 { 3474 {
3046 cursor_pnt=*pnt; 3475 cursor_pnt = *pnt;
3047 } 3476 }
3048 else 3477 else
3049 { 3478 {
3050 pro=transform_get_projection(this_->trans_cursor); 3479 pro = transform_get_projection(this_->trans_cursor);
3051 if (!pro) 3480 if (!pro)
3052 return; 3481 return;
3053 transform(this_->trans_cursor, pro, &nv->coord, &cursor_pnt, 1, 0, 0, NULL); 3482 transform(this_->trans_cursor, pro, &nv->coord, &cursor_pnt, 1, 0, 0, NULL);
3054 } 3483 }
3055 //dbg(0,"xx=%d\n",cursor_pnt.x); 3484 ////DBG dbg(0,"xx=%d\n",cursor_pnt.x);
3056 //dbg(0,"yy=%d\n",cursor_pnt.y); 3485 ////DBG dbg(0,"yy=%d\n",cursor_pnt.y);
3057 3486
3058 global_vehicle_pos_onscreen.x=cursor_pnt.x; 3487 global_vehicle_pos_onscreen.x = cursor_pnt.x;
3059 global_vehicle_pos_onscreen.y=cursor_pnt.y; 3488 global_vehicle_pos_onscreen.y = cursor_pnt.y;
3060 3489
3061
3062 //dbg(0,"xx=%d\n",pnt->x); 3490 ////DBG dbg(0,"xx=%d\n",pnt->x);
3063 //dbg(0,"yy=%d\n",pnt->y); 3491 ////DBG dbg(0,"yy=%d\n",pnt->y);
3064 //dbg(0,"vehicle_draw_001\n"); 3492 ////DBG dbg(0,"vehicle_draw_001\n");
3065 vehicle_draw(nv->vehicle, this_->gra, &cursor_pnt, pnt ? 0:1, nv->dir-transform_get_yaw(this_->trans_cursor), nv->speed); 3493 vehicle_draw(nv->vehicle, this_->gra, &cursor_pnt, pnt ? 0 : 1, nv->dir - transform_get_yaw(this_->trans_cursor), nv->speed);
3066#if 0 3494#if 0
3067 if (pnt) 3495 if (pnt)
3068 pnt2=*pnt; 3496 pnt2=*pnt;
3069 else { 3497 else
3498 {
3070 pro=transform_get_projection(this_->trans); 3499 pro=transform_get_projection(this_->trans);
3071 transform(this_->trans, pro, &nv->coord, &pnt2, 1); 3500 transform(this_->trans, pro, &nv->coord, &pnt2, 1);
3072 } 3501 }
3073#if 1 3502#if 1
3074 cursor_draw(nv->cursor, &pnt2, nv->dir-transform_get_angle(this_->trans, 0), nv->speed > 2, pnt == NULL); 3503 cursor_draw(nv->cursor, &pnt2, nv->dir-transform_get_angle(this_->trans, 0), nv->speed > 2, pnt == NULL);
3076 cursor_draw(nv->cursor, &pnt2, nv->dir-transform_get_angle(this_->trans, 0), nv->speed > 2, 1); 3505 cursor_draw(nv->cursor, &pnt2, nv->dir-transform_get_angle(this_->trans, 0), nv->speed > 2, 1);
3077#endif 3506#endif
3078#endif 3507#endif
3079} 3508}
3080 3509
3081static void
3082navit_vehicle_update(struct navit *this_, struct navit_vehicle *nv) 3510static void navit_vehicle_update(struct navit *this_, struct navit_vehicle *nv)
3083{ 3511{
3084 // dbg(0,"EEnter\n"); 3512 //DBG dbg(0,"EEnter\n");
3085 3513
3086 struct attr attr_valid, attr_dir, attr_speed, attr_pos; 3514 struct attr attr_valid, attr_dir, attr_speed, attr_pos;
3087 struct pcoord cursor_pc; 3515 struct pcoord cursor_pc;
3088 struct point cursor_pnt, *pnt=&cursor_pnt; 3516 struct point cursor_pnt, *pnt = &cursor_pnt;
3089 struct tracking *tracking=NULL; 3517 struct tracking *tracking = NULL;
3090 struct pcoord pc[16]; 3518 struct pcoord pc[16];
3091 enum projection pro=transform_get_projection(this_->trans_cursor); 3519 enum projection pro = transform_get_projection(this_->trans_cursor);
3092 int count; 3520 int count;
3093 int (*get_attr)(void *, enum attr_type, struct attr *, struct attr_iter *); 3521 int (*get_attr)(void *, enum attr_type, struct attr *, struct attr_iter *);
3094 void *attr_object; 3522 void *attr_object;
3095 char *destination_file; 3523 char *destination_file;
3096 3524
3097 // dbg(0,"navit_vehicle_update_001 %d\n",pro); 3525 // //DBG dbg(0,"navit_vehicle_update_001 %d\n",pro);
3098 //profile(0,NULL); 3526 //profile(0,NULL);
3099 if (this_->ready != 3) { 3527 if (this_->ready != 3)
3528 {
3100 //profile(0,"return 1\n"); 3529 //profile(0,"return 1\n");
3101 return; 3530 return;
3102 } 3531 }
3103 navit_layout_switch(this_); 3532 navit_layout_switch(this_);
3104 if (this_->vehicle == nv && this_->tracking_flag) 3533 if (this_->vehicle == nv && this_->tracking_flag)
3105 tracking=this_->tracking; 3534 tracking = this_->tracking;
3106 if (tracking) { 3535 if (tracking)
3536 {
3107 tracking_update(tracking, nv->vehicle, this_->vehicleprofile, pro); 3537 tracking_update(tracking, nv->vehicle, this_->vehicleprofile, pro);
3108 attr_object=tracking; 3538 attr_object = tracking;
3109 get_attr=(int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))tracking_get_attr; 3539 get_attr = (int(*)(void *, enum attr_type, struct attr *, struct attr_iter *)) tracking_get_attr;
3110 } else { 3540 }
3541 else
3542 {
3111 attr_object=nv->vehicle; 3543 attr_object = nv->vehicle;
3112 get_attr=(int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))vehicle_get_attr; 3544 get_attr = (int(*)(void *, enum attr_type, struct attr *, struct attr_iter *)) vehicle_get_attr;
3113 } 3545 }
3114 if (get_attr(attr_object, attr_position_valid, &attr_valid, NULL)) 3546 if (get_attr(attr_object, attr_position_valid, &attr_valid, NULL))
3115 if (!attr_valid.u.num != attr_position_valid_invalid) 3547 if (!attr_valid.u.num != attr_position_valid_invalid)
3116 return; 3548 return;
3117 if (! get_attr(attr_object, attr_position_direction, &attr_dir, NULL) || 3549 if (!get_attr(attr_object, attr_position_direction, &attr_dir, NULL) || !get_attr(attr_object, attr_position_speed, &attr_speed, NULL) || !get_attr(attr_object, attr_position_coord_geo, &attr_pos, NULL))
3118 ! get_attr(attr_object, attr_position_speed, &attr_speed, NULL) || 3550 {
3119 ! get_attr(attr_object, attr_position_coord_geo, &attr_pos, NULL)) {
3120 // profile(0,"return 2\n"); 3551 // profile(0,"return 2\n");
3121 return; 3552 return;
3122 } 3553 }
3123 nv->dir=*attr_dir.u.numd; 3554 nv->dir = *attr_dir.u.numd;
3124 nv->speed=*attr_speed.u.numd; 3555 nv->speed = *attr_speed.u.numd;
3125 transform_from_geo(pro, attr_pos.u.coord_geo, &nv->coord); 3556 transform_from_geo(pro, attr_pos.u.coord_geo, &nv->coord);
3126 if (nv != this_->vehicle) 3557 if (nv != this_->vehicle)
3127 { 3558 {
3128 //dbg(0,"---> 2 x=%d\n", nv->coord.x); 3559 ////DBG dbg(0,"---> 2 x=%d\n", nv->coord.x);
3129 //dbg(0,"---> 2 y=%d\n", nv->coord.y); 3560 ////DBG dbg(0,"---> 2 y=%d\n", nv->coord.y);
3130 // dbg(0,"vehicle_draw_002\n"); 3561 // //DBG dbg(0,"vehicle_draw_002\n");
3131 navit_vehicle_draw(this_, nv, NULL); 3562 navit_vehicle_draw(this_, nv, NULL);
3132 // profile(0,"return 3\n"); 3563 // profile(0,"return 3\n");
3133 return; 3564 return;
3134 } 3565 }
3135 cursor_pc.x = nv->coord.x; 3566 cursor_pc.x = nv->coord.x;
3136 cursor_pc.y = nv->coord.y; 3567 cursor_pc.y = nv->coord.y;
3137 cursor_pc.pro = pro; 3568 cursor_pc.pro = pro;
3138 if (this_->route) { 3569 if (this_->route)
3570 {
3139 if (tracking) 3571 if (tracking)
3140 route_set_position_from_tracking(this_->route, tracking, pro); 3572 route_set_position_from_tracking(this_->route, tracking, pro);
3141 else 3573 else
3142 route_set_position(this_->route, &cursor_pc); 3574 route_set_position(this_->route, &cursor_pc);
3143 } 3575 }
3144 callback_list_call_attr_0(this_->attr_cbl, attr_position); 3576 callback_list_call_attr_0(this_->attr_cbl, attr_position);
3145 navit_textfile_debug_log(this_, "type=trackpoint_tracked"); 3577 // navit_textfile_debug_log(this_, "type=trackpoint_tracked");
3146 if (this_->gui && nv->speed > MYSTERY_SPEED) 3578 if (this_->gui && nv->speed > MYSTERY_SPEED)
3147 navit_disable_suspend(); 3579 navit_disable_suspend();
3148 transform(this_->trans_cursor, pro, &nv->coord, &cursor_pnt, 1, 0, 0, NULL); 3580 transform(this_->trans_cursor, pro, &nv->coord, &cursor_pnt, 1, 0, 0, NULL);
3149 if (this_->button_pressed != 1 && this_->follow_cursor && nv->follow_curr <= nv->follow && 3581 if (this_->button_pressed != 1 && this_->follow_cursor && nv->follow_curr <= nv->follow && (nv->follow_curr == 1 || !transform_within_border(this_->trans_cursor, &cursor_pnt, this_->border)))
3150 (nv->follow_curr == 1 || !transform_within_border(this_->trans_cursor, &cursor_pnt, this_->border)))
3151 { 3582 {
3152 navit_set_center_cursor_draw(this_); 3583 navit_set_center_cursor_draw(this_);
3153 //dbg(0,"---> xxCENTER\n"); 3584 ////DBG dbg(0,"---> xxCENTER\n");
3154 //dbg(0,"---> 3 x=%d\n", nv->coord.x); 3585 ////DBG dbg(0,"---> 3 x=%d\n", nv->coord.x);
3155 //dbg(0,"---> 3 y=%d\n", nv->coord.y); 3586 ////DBG dbg(0,"---> 3 y=%d\n", nv->coord.y);
3156 3587
3157 //dbg(0,"---> 4 x=%d\n", cursor_pnt.x); 3588 ////DBG dbg(0,"---> 4 x=%d\n", cursor_pnt.x);
3158 //dbg(0,"---> 4 y=%d\n", cursor_pnt.y); 3589 ////DBG dbg(0,"---> 4 y=%d\n", cursor_pnt.y);
3159 3590
3160 //global_vehicle_pos_onscreen.x=cursor_pnt.x; 3591 //global_vehicle_pos_onscreen.x=cursor_pnt.x;
3161 //global_vehicle_pos_onscreen.y=cursor_pnt.y; 3592 //global_vehicle_pos_onscreen.y=cursor_pnt.y;
3162 3593
3163 } 3594 }
3164 else 3595 else
3165 { 3596 {
3166 //dbg(0,"vehicle_draw_003\n"); 3597 ////DBG dbg(0,"vehicle_draw_003\n");
3167 navit_vehicle_draw(this_, nv, pnt); 3598 navit_vehicle_draw(this_, nv, pnt);
3168 //global_vehicle_pos_onscreen.x=pnt->x; 3599 //global_vehicle_pos_onscreen.x=pnt->x;
3169 //global_vehicle_pos_onscreen.y=pnt->y; 3600 //global_vehicle_pos_onscreen.y=pnt->y;
3170 //dbg(0,"---> x=%d\n", pnt->x); 3601 ////DBG dbg(0,"---> x=%d\n", pnt->x);
3171 //dbg(0,"---> y=%d\n", pnt->y); 3602 ////DBG dbg(0,"---> y=%d\n", pnt->y);
3172 } 3603 }
3173 3604
3174 if (nv->follow_curr > 1) 3605 if (nv->follow_curr > 1)
3175 nv->follow_curr--; 3606 nv->follow_curr--;
3176 else 3607 else
3177 nv->follow_curr=nv->follow; 3608 nv->follow_curr = nv->follow;
3178 callback_list_call_attr_2(this_->attr_cbl, attr_position_coord_geo, this_, nv->vehicle); 3609 callback_list_call_attr_2(this_->attr_cbl, attr_position_coord_geo, this_, nv->vehicle);
3179 3610
3180 /* Finally, if we reached our destination, stop navigation. */ 3611 /* Finally, if we reached our destination, stop navigation. */
3181 if (this_->route) { 3612 if (this_->route)
3613 {
3182 switch(route_destination_reached(this_->route)) { 3614 switch (route_destination_reached(this_->route))
3615 {
3183 case 1: 3616 case 1:
3184 route_remove_waypoint(this_->route); 3617 route_remove_waypoint(this_->route);
3185 count=route_get_destinations(this_->route, pc, 16); 3618 count = route_get_destinations(this_->route, pc, 16);
3619
3186 destination_file = bookmarks_get_destination_file(TRUE); 3620 // destination_file = bookmarks_get_destination_file(TRUE);
3187 bookmarks_append_coord(this_->bookmarks, destination_file, pc, count, "former_itinerary_part", NULL, NULL, this_->recentdest_count); 3621 // bookmarks_append_coord(this_->bookmarks, destination_file, pc, count, "former_itinerary_part", NULL, NULL, this_->recentdest_count);
3622
3188#ifdef HAVE_API_ANDROID 3623#ifdef HAVE_API_ANDROID
3189 // waypoint reached 3624 // waypoint reached
3190 android_return_generic_int(5, 1); 3625 android_return_generic_int(5, 1);
3626 android_send_generic_text(1,"+*#O:Waypoint reached\n");
3627 // say it
3628 navit_say(this_, _("Waypoint reached"));
3191#endif 3629#endif
3192 break; 3630 break;
3193 case 2: 3631 case 2:
3194 navit_set_destination(this_, NULL, NULL, 0); 3632 navit_set_destination(this_, NULL, NULL, 0);
3195 // ** inform java that we reached our destination ** 3633 // ** inform java that we reached our destination **
3196#ifdef HAVE_API_ANDROID 3634#ifdef HAVE_API_ANDROID
3197 android_return_generic_int(4, 1); 3635 android_return_generic_int(4, 1);
3636 android_send_generic_text(1,"+*#O:You have reached your destination\n");
3637 // say it
3638 navit_say(this_, _("You have reached your destination"));
3198#endif 3639#endif
3199 break; 3640 break;
3200 } 3641 }
3201 } 3642 }
3202 //profile(0,"return 5\n"); 3643 //profile(0,"return 5\n");
3203 // dbg(0,"navit_vehicle_update_999\n"); 3644 // //DBG dbg(0,"navit_vehicle_update_999\n");
3204} 3645}
3205 3646
3206/** 3647/**
3207 * Set the position of the vehicle 3648 * Set the position of the vehicle
3208 * 3649 *
3209 * @param navit The navit instance 3650 * @param navit The navit instance
3210 * @param c The coordinate to set as position 3651 * @param c The coordinate to set as position
3211 * @returns nothing 3652 * @returns nothing
3212 */ 3653 */
3213 3654
3214void
3215navit_set_position(struct navit *this_, struct pcoord *c) 3655void navit_set_position(struct navit *this_, struct pcoord *c)
3216{ 3656{
3217 //dbg(0,"EEnter\n"); 3657 //DBG dbg(0,"EEnter\n");
3218 3658
3219 if (this_->route) { 3659 if (this_->route)
3660 {
3220 route_set_position(this_->route, c); 3661 route_set_position(this_->route, c);
3221 callback_list_call_attr_0(this_->attr_cbl, attr_position); 3662 callback_list_call_attr_0(this_->attr_cbl, attr_position);
3222 } 3663 }
3223 if (this_->ready == 3) 3664 if (this_->ready == 3)
3224 navit_draw(this_); 3665 navit_draw(this_);
3225} 3666}
3226 3667
3227static int
3228navit_set_vehicleprofile(struct navit *this_, char *name) 3668static int navit_set_vehicleprofile(struct navit *this_, char *name)
3229{ 3669{
3230 //dbg(0,"EEnter\n"); 3670 ////DBG dbg(0,"EEnter\n");
3231 3671
3232 struct attr attr; 3672 struct attr attr;
3233 GList *l; 3673 GList *l;
3234 l=this_->vehicleprofiles; 3674 l = this_->vehicleprofiles;
3235 while (l) { 3675 while (l)
3676 {
3236 if (vehicleprofile_get_attr(l->data, attr_name, &attr, NULL)) { 3677 if (vehicleprofile_get_attr(l->data, attr_name, &attr, NULL))
3678 {
3237 if (!strcmp(attr.u.str, name)) { 3679 if (!strcmp(attr.u.str, name))
3680 {
3238 this_->vehicleprofile=l->data; 3681 this_->vehicleprofile = l->data;
3239 if (this_->route) 3682 if (this_->route)
3240 route_set_profile(this_->route, this_->vehicleprofile); 3683 route_set_profile(this_->route, this_->vehicleprofile);
3241 return 1; 3684 return 1;
3242 } 3685 }
3243 } 3686 }
3244 l=g_list_next(l); 3687 l = g_list_next(l);
3245 } 3688 }
3246 return 0; 3689 return 0;
3247} 3690}
3248 3691
3249static void
3250navit_set_vehicle(struct navit *this_, struct navit_vehicle *nv) 3692static void navit_set_vehicle(struct navit *this_, struct navit_vehicle *nv)
3251{ 3693{
3252 //dbg(0,"EEnter\n"); 3694 ////DBG dbg(0,"EEnter\n");
3253 3695
3254 struct attr attr; 3696 struct attr attr;
3255 this_->vehicle=nv; 3697 this_->vehicle = nv;
3256 if (nv && vehicle_get_attr(nv->vehicle, attr_profilename, &attr, NULL)) { 3698 if (nv && vehicle_get_attr(nv->vehicle, attr_profilename, &attr, NULL))
3699 {
3257 if (navit_set_vehicleprofile(this_, attr.u.str)) 3700 if (navit_set_vehicleprofile(this_, attr.u.str))
3701 {
3258 return; 3702 return;
3259 } 3703 }
3704 }
3260 if (!navit_set_vehicleprofile(this_,"car")) { 3705 if (!navit_set_vehicleprofile(this_, "car"))
3706 {
3261 /* We do not have a fallback "car" profile 3707 /* We do not have a fallback "car" profile
3262 * so lets set any profile */ 3708 * so lets set any profile */
3263 GList *l; 3709 GList *l;
3264 l=this_->vehicleprofiles; 3710 l = this_->vehicleprofiles;
3265 if (l) { 3711 if (l)
3712 {
3266 this_->vehicleprofile=l->data; 3713 this_->vehicleprofile = l->data;
3267 if (this_->route) 3714 if (this_->route)
3715 {
3268 route_set_profile(this_->route, this_->vehicleprofile); 3716 route_set_profile(this_->route, this_->vehicleprofile);
3717 }
3269 } 3718 }
3270 } 3719 }
3271} 3720}
3272 3721
3273/** 3722/**
3275 * 3724 *
3276 * @param navit The navit instance 3725 * @param navit The navit instance
3277 * @param v The vehicle instance 3726 * @param v The vehicle instance
3278 * @returns 1 for success 3727 * @returns 1 for success
3279 */ 3728 */
3280static int
3281navit_add_vehicle(struct navit *this_, struct vehicle *v) 3729int navit_add_vehicle(struct navit *this_, struct vehicle *v)
3282{ 3730{
3283 //dbg(0,"EEnter\n"); 3731 ////DBG dbg(0,"EEnter\n");
3284 3732
3285 struct navit_vehicle *nv=g_new0(struct navit_vehicle, 1); 3733 struct navit_vehicle *nv=g_new0(struct navit_vehicle, 1);
3286 struct attr follow, active, animate; 3734 struct attr follow, active, animate;
3287 nv->vehicle=v; 3735 nv->vehicle = v;
3288 nv->follow=0; 3736 nv->follow = 0;
3289 nv->last.x = 0; 3737 nv->last.x = 0;
3290 nv->last.y = 0; 3738 nv->last.y = 0;
3291 nv->animate_cursor=0; 3739 nv->animate_cursor = 0;
3292 if ((vehicle_get_attr(v, attr_follow, &follow, NULL))) 3740 if ((vehicle_get_attr(v, attr_follow, &follow, NULL)))
3293 nv->follow=follow.u.num; 3741 nv->follow = follow.u.num;
3294 nv->follow_curr=nv->follow; 3742 nv->follow_curr = nv->follow;
3295 this_->vehicles=g_list_append(this_->vehicles, nv); 3743 this_->vehicles = g_list_append(this_->vehicles, nv);
3296 if ((vehicle_get_attr(v, attr_active, &active, NULL)) && active.u.num) 3744 if ((vehicle_get_attr(v, attr_active, &active, NULL)) && active.u.num)
3297 navit_set_vehicle(this_, nv); 3745 navit_set_vehicle(this_, nv);
3298 if ((vehicle_get_attr(v, attr_animate, &animate, NULL))) 3746 if ((vehicle_get_attr(v, attr_animate, &animate, NULL)))
3299 nv->animate_cursor=animate.u.num; 3747 nv->animate_cursor = animate.u.num;
3300 nv->callback.type=attr_callback; 3748 nv->callback.type = attr_callback;
3301 nv->callback.u.callback=callback_new_attr_2(callback_cast(navit_vehicle_update), attr_position_coord_geo, this_, nv); 3749 nv->callback.u.callback = callback_new_attr_2(callback_cast(navit_vehicle_update), attr_position_coord_geo, this_, nv);
3302 vehicle_add_attr(nv->vehicle, &nv->callback); 3750 vehicle_add_attr(nv->vehicle, &nv->callback);
3303 vehicle_set_attr(nv->vehicle, &this_->self); 3751 vehicle_set_attr(nv->vehicle, &this_->self);
3304 return 1; 3752 return 1;
3305} 3753}
3306 3754
3307
3308
3309
3310struct gui * 3755struct gui *
3311navit_get_gui(struct navit *this_) 3756navit_get_gui(struct navit *this_)
3312{ 3757{
3313 return this_->gui; 3758 return this_->gui;
3314} 3759}
3335navit_get_displaylist(struct navit *this_) 3780navit_get_displaylist(struct navit *this_)
3336{ 3781{
3337 return this_->displaylist; 3782 return this_->displaylist;
3338} 3783}
3339 3784
3340void
3341navit_layout_switch(struct navit *n) 3785void navit_layout_switch(struct navit *n)
3342{ 3786{
3343 //dbg(0,"EEnter\n"); 3787 ////DBG dbg(0,"EEnter\n");
3344 3788
3345 int currTs=0; 3789 int currTs = 0;
3346 struct attr iso8601_attr,geo_attr,valid_attr,layout_attr; 3790 struct attr iso8601_attr, geo_attr, valid_attr, layout_attr;
3347 double trise,tset,trise_actual; 3791 double trise, tset, trise_actual;
3348 struct layout *l; 3792 struct layout *l;
3349 int year, month, day; 3793 int year, month, day;
3350 3794
3351 if (navit_get_attr(n,attr_layout,&layout_attr,NULL)!=1) { 3795 if (navit_get_attr(n, attr_layout, &layout_attr, NULL) != 1)
3796 {
3352 return; //No layout - nothing to switch 3797 return; //No layout - nothing to switch
3353 } 3798 }
3354 if (!n->vehicle) 3799 if (!n->vehicle)
3355 return;
3356 l=layout_attr.u.layout;
3357
3358 if (l->dayname || l->nightname) {
3359 //Ok, we know that we have profile to switch
3360
3361 //Check that we aren't calculating too fast
3362 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_time_iso8601,&iso8601_attr,NULL)==1) {
3363 currTs=iso8601_to_secs(iso8601_attr.u.str);
3364 dbg(1,"currTs: %u:%u\n",currTs%86400/3600,((currTs%86400)%3600)/60);
3365 }
3366 if (currTs-(n->prevTs)<60) {
3367 //We've have to wait a little
3368 return;
3369 }
3370 if (sscanf(iso8601_attr.u.str,"%d-%02d-%02dT",&year,&month,&day) != 3)
3371 return; 3800 return;
3801 l = layout_attr.u.layout;
3802
3803 if (l->dayname || l->nightname)
3804 {
3805 //Ok, we know that we have profile to switch
3806
3807 //Check that we aren't calculating too fast
3808 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_time_iso8601, &iso8601_attr, NULL) == 1)
3809 {
3810 currTs = iso8601_to_secs(iso8601_attr.u.str);
3811 // dbg(1, "currTs: %u:%u\n", currTs % 86400 / 3600, ((currTs % 86400) % 3600) / 60);
3812 }
3813 if (currTs - (n->prevTs) < 60)
3814 {
3815 //We've have to wait a little
3816 return;
3817 }
3818 if (sscanf(iso8601_attr.u.str, "%d-%02d-%02dT", &year, &month, &day) != 3)
3819 return;
3372 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_valid, &valid_attr,NULL) && valid_attr.u.num==attr_position_valid_invalid) { 3820 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_valid, &valid_attr, NULL) && valid_attr.u.num == attr_position_valid_invalid)
3821 {
3373 return; //No valid fix yet 3822 return; //No valid fix yet
3374 } 3823 }
3375 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_coord_geo,&geo_attr,NULL)!=1) { 3824 if (vehicle_get_attr(n->vehicle->vehicle, attr_position_coord_geo, &geo_attr, NULL) != 1)
3825 {
3376 //No position - no sun 3826 //No position - no sun
3377 return; 3827 return;
3378 } 3828 }
3379 3829
3380 //We calculate sunrise anyway, cause it is needed both for day and for night 3830 //We calculate sunrise anyway, cause it is needed both for day and for night
3381 if (__sunriset__(year,month,day,geo_attr.u.coord_geo->lng,geo_attr.u.coord_geo->lat,-5,1,&trise,&tset)!=0) { 3831 if (__sunriset__(year, month, day, geo_attr.u.coord_geo->lng, geo_attr.u.coord_geo->lat, -5, 1, &trise, &tset) != 0)
3832 {
3382 //near the pole sun never rises/sets, so we should never switch profiles 3833 //near the pole sun never rises/sets, so we should never switch profiles
3383 dbg(1,"trise: %u:%u, sun never visible, never switch profile\n",HOURS(trise),MINUTES(trise)); 3834 // dbg(1, "trise: %u:%u, sun never visible, never switch profile\n", HOURS(trise), MINUTES(trise));
3384 n->prevTs=currTs; 3835 n->prevTs = currTs;
3385 return; 3836 return;
3386 } 3837 }
3387 3838
3388 trise_actual=trise; 3839 trise_actual = trise;
3389 dbg(1,"trise: %u:%u\n",HOURS(trise),MINUTES(trise)); 3840 // dbg(1, "trise: %u:%u\n", HOURS(trise), MINUTES(trise));
3390 if (l->dayname) { 3841 if (l->dayname)
3391 3842 {
3392 if ((HOURS(trise)*60+MINUTES(trise)==(currTs%86400)/60) || 3843
3393 (n->prevTs==0 && ((HOURS(trise)*60+MINUTES(trise)<(currTs%86400)/60)))) { 3844 if ((HOURS(trise) * 60 + MINUTES(trise) == (currTs % 86400) / 60) || (n->prevTs == 0 && ((HOURS(trise) * 60 + MINUTES(trise) < (currTs % 86400) / 60))))
3845 {
3394 //The sun is rising now! 3846 //The sun is rising now!
3395 if (strcmp(l->name,l->dayname)) { 3847 if (strcmp(l->name, l->dayname))
3848 {
3396 navit_set_layout_by_name(n,l->dayname); 3849 navit_set_layout_by_name(n, l->dayname);
3850 }
3397 } 3851 }
3398 }
3399 } 3852 }
3400 if (l->nightname) { 3853 if (l->nightname)
3854 {
3401 if (__sunriset__(year,month,day,geo_attr.u.coord_geo->lng,geo_attr.u.coord_geo->lat,-5,1,&trise,&tset)!=0) { 3855 if (__sunriset__(year, month, day, geo_attr.u.coord_geo->lng, geo_attr.u.coord_geo->lat, -5, 1, &trise, &tset) != 0)
3856 {
3402 //near the pole sun never rises/sets, so we should never switch profiles 3857 //near the pole sun never rises/sets, so we should never switch profiles
3403 dbg(1,"tset: %u:%u, sun always visible, never switch profile\n",HOURS(tset),MINUTES(tset)); 3858 // dbg(1,"tset: %u:%u, sun always visible, never switch profile\n",HOURS(tset), MINUTES(tset));
3859 n->prevTs = currTs;
3860 return;
3861 }
3862 // dbg(1, "tset: %u:%u\n", HOURS(tset), MINUTES(tset));
3863 if (HOURS(tset) * 60 + MINUTES(tset) == ((currTs % 86400) / 60) || (n->prevTs == 0 && (((HOURS(tset) * 60 + MINUTES(tset) < (currTs % 86400) / 60)) || ((HOURS(trise_actual) * 60 + MINUTES(trise_actual) > (currTs % 86400) / 60)))))
3864 {
3865 //Time to sleep
3866 if (strcmp(l->name, l->nightname))
3867 {
3868 navit_set_layout_by_name(n, l->nightname);
3869 }
3870 }
3871 }
3872
3404 n->prevTs=currTs; 3873 n->prevTs = currTs;
3405 return;
3406 }
3407 dbg(1,"tset: %u:%u\n",HOURS(tset),MINUTES(tset));
3408 if (HOURS(tset)*60+MINUTES(tset)==((currTs%86400)/60)
3409 || (n->prevTs==0 && (((HOURS(tset)*60+MINUTES(tset)<(currTs%86400)/60)) ||
3410 ((HOURS(trise_actual)*60+MINUTES(trise_actual)>(currTs%86400)/60))))) {
3411 //Time to sleep
3412 if (strcmp(l->name,l->nightname)) {
3413 navit_set_layout_by_name(n,l->nightname);
3414 } 3874 }
3415 }
3416 }
3417
3418 n->prevTs=currTs;
3419 }
3420} 3875}
3421 3876
3422int
3423navit_set_vehicle_by_name(struct navit *n,const char *name) 3877int navit_set_vehicle_by_name(struct navit *n, const char *name)
3424{ 3878{
3425 //dbg(0,"EEnter\n"); 3879 ////DBG dbg(0,"EEnter\n");
3426 3880
3427 struct vehicle *v; 3881 struct vehicle *v;
3428 struct attr_iter *iter; 3882 struct attr_iter *iter;
3429 struct attr vehicle_attr, name_attr; 3883 struct attr vehicle_attr, name_attr;
3430 3884
3431 iter=navit_attr_iter_new(); 3885 iter = navit_attr_iter_new();
3432 3886
3433 while (navit_get_attr(n,attr_vehicle,&vehicle_attr,iter)) { 3887 while (navit_get_attr(n, attr_vehicle, &vehicle_attr, iter))
3888 {
3434 v=vehicle_attr.u.vehicle; 3889 v = vehicle_attr.u.vehicle;
3435 vehicle_get_attr(v,attr_name,&name_attr,NULL); 3890 vehicle_get_attr(v, attr_name, &name_attr, NULL);
3436 if (name_attr.type==attr_name) { 3891 if (name_attr.type == attr_name)
3892 {
3437 if (!strcmp(name,name_attr.u.str)) { 3893 if (!strcmp(name, name_attr.u.str))
3894 {
3438 navit_set_attr(n,&vehicle_attr); 3895 navit_set_attr(n, &vehicle_attr);
3439 navit_attr_iter_destroy(iter); 3896 navit_attr_iter_destroy(iter);
3440 return 1; 3897 return 1;
3441 } 3898 }
3442 } 3899 }
3443 } 3900 }
3444 navit_attr_iter_destroy(iter); 3901 navit_attr_iter_destroy(iter);
3445 return 0;
3446}
3447
3448int
3449navit_set_layout_by_name(struct navit *n,const char *name)
3450{
3451 //dbg(0,"EEnter\n");
3452
3453 struct layout *l;
3454 struct attr_iter iter;
3455 struct attr layout_attr;
3456
3457 iter.u.list=0x00;
3458
3459 if (navit_get_attr(n,attr_layout,&layout_attr,&iter)!=1) {
3460 return 0; //No layouts - nothing to do
3461 }
3462 if (iter.u.list==NULL) {
3463 return 0; 3902 return 0;
3464 } 3903}
3465 3904
3905int navit_set_layout_by_name(struct navit *n, const char *name)
3906{
3907 ////DBG dbg(0,"EEnter\n");
3908
3909 struct layout *l;
3910 struct attr_iter iter;
3911 struct attr layout_attr;
3912
3913 iter.u.list = 0x00;
3914
3915 if (navit_get_attr(n, attr_layout, &layout_attr, &iter) != 1)
3916 {
3917 return 0; //No layouts - nothing to do
3918 }
3919 if (iter.u.list == NULL)
3920 {
3921 return 0;
3922 }
3923
3466 iter.u.list=g_list_first(iter.u.list); 3924 iter.u.list = g_list_first(iter.u.list);
3467 3925
3468 while(iter.u.list) { 3926 while (iter.u.list)
3927 {
3469 l=(struct layout*)iter.u.list->data; 3928 l = (struct layout*) iter.u.list->data;
3470 if (!strcmp(name,l->name)) { 3929 if (!strcmp(name, l->name))
3930 {
3471 layout_attr.u.layout=l; 3931 layout_attr.u.layout = l;
3472 layout_attr.type=attr_layout; 3932 layout_attr.type = attr_layout;
3473 navit_set_attr(n,&layout_attr); 3933 navit_set_attr(n, &layout_attr);
3474 iter.u.list=g_list_first(iter.u.list); 3934 iter.u.list = g_list_first(iter.u.list);
3475 return 1; 3935 return 1;
3476 } 3936 }
3477 iter.u.list=g_list_next(iter.u.list); 3937 iter.u.list = g_list_next(iter.u.list);
3478 } 3938 }
3479 3939
3480 iter.u.list=g_list_first(iter.u.list); 3940 iter.u.list = g_list_first(iter.u.list);
3481 return 0; 3941 return 0;
3482} 3942}
3483 3943
3484void
3485navit_disable_suspend() { 3944void navit_disable_suspend()
3945{
3486 //dbg(0,"EEnter\n"); 3946 ////DBG dbg(0,"EEnter\n");
3487 3947
3488 gui_disable_suspend(global_navit->gui); 3948 gui_disable_suspend(global_navit->gui);
3489 callback_list_call_attr_0(global_navit->attr_cbl,attr_unsuspend); 3949 callback_list_call_attr_0(global_navit->attr_cbl, attr_unsuspend);
3490} 3950}
3491 3951
3492int
3493navit_block(struct navit *this_, int block) 3952int navit_block(struct navit *this_, int block)
3494{ 3953{
3495 //dbg(0,"EEnter\n"); 3954 ////DBG dbg(0,"EEnter\n");
3496 3955
3497 if (block > 0) { 3956 if (block > 0)
3957 {
3498 this_->blocked |= 1; 3958 this_->blocked |= 1;
3499 if (graphics_draw_cancel(this_->gra, this_->displaylist)) 3959 if (graphics_draw_cancel(this_->gra, this_->displaylist))
3500 this_->blocked |= 2; 3960 this_->blocked |= 2;
3501 return 0; 3961 return 0;
3502 } 3962 }
3503 if ((this_->blocked & 2) || block < 0) { 3963 if ((this_->blocked & 2) || block < 0)
3964 {
3504 this_->blocked=0; 3965 this_->blocked = 0;
3505 navit_draw(this_); 3966 navit_draw(this_);
3506 return 1; 3967 return 1;
3507 } 3968 }
3508 this_->blocked=0; 3969 this_->blocked = 0;
3509 return 0; 3970 return 0;
3510} 3971}
3511 3972
3512void
3513navit_destroy(struct navit *this_) 3973void navit_destroy(struct navit *this_)
3514{ 3974{
3515 //dbg(0,"EEnter\n"); 3975 dbg(0,"EEnter\n");
3516 3976
3517 struct mapset*ms; 3977 struct mapset*ms;
3518 callback_list_call_attr_1(this_->attr_cbl, attr_destroy, this_); 3978 callback_list_call_attr_1(this_->attr_cbl, attr_destroy, this_);
3519 3979
3520 // dbg(0,"enter"); 3980 // //DBG dbg(0,"enter");
3521 3981
3522 /* TODO: destroy objects contained in this_ */ 3982 /* TODO: destroy objects contained in this_ */
3523 if (this_->vehicle) 3983 if (this_->vehicle)
3524 vehicle_destroy(this_->vehicle->vehicle); 3984 vehicle_destroy(this_->vehicle->vehicle);
3525 if (this_->bookmarks) 3985 if (this_->bookmarks)
3526 { 3986 {
3527 dbg(0,"save position to file"); 3987 dbg(0, "save position to file\n");
3528 char *center_file = bookmarks_get_center_file(TRUE); 3988 char *center_file = bookmarks_get_center_file(TRUE);
3529 bookmarks_write_center_to_file(this_->bookmarks, center_file); 3989 bookmarks_write_center_to_file(this_->bookmarks, center_file);
3530 g_free(center_file); 3990 g_free(center_file);
3531 bookmarks_destroy(this_->bookmarks); 3991 bookmarks_destroy(this_->bookmarks);
3992 dbg(0, "save position to file -> ready\n");
3532 } 3993 }
3994 dbg(0,"ex 001\n");
3533 callback_destroy(this_->nav_speech_cb); 3995 callback_destroy(this_->nav_speech_cb);
3996 dbg(0,"ex 002\n");
3534 callback_destroy(this_->roadbook_callback); 3997 callback_destroy(this_->roadbook_callback);
3998 dbg(0,"ex 003\n");
3535 callback_destroy(this_->popup_callback); 3999 callback_destroy(this_->popup_callback);
4000 dbg(0,"ex 004\n");
3536 callback_destroy(this_->motion_timeout_callback); 4001 callback_destroy(this_->motion_timeout_callback);
4002 dbg(0,"ex 005\n");
3537 callback_destroy(this_->progress_cb); 4003 callback_destroy(this_->progress_cb);
4004 dbg(0,"ex 006\n");
3538 if(this_->gra) 4005 if (this_->gra)
3539 graphics_remove_callback(this_->gra, this_->resize_callback); 4006 graphics_remove_callback(this_->gra, this_->resize_callback);
3540 callback_destroy(this_->resize_callback); 4007 callback_destroy(this_->resize_callback);
4008 dbg(0,"ex 007\n");
3541 if(this_->gra) 4009 if (this_->gra)
3542 graphics_remove_callback(this_->gra, this_->button_callback); 4010 graphics_remove_callback(this_->gra, this_->button_callback);
3543 callback_destroy(this_->button_callback); 4011 callback_destroy(this_->button_callback);
4012 dbg(0,"ex 008\n");
3544 if(this_->gra) 4013 if (this_->gra)
3545 graphics_remove_callback(this_->gra, this_->motion_callback); 4014 graphics_remove_callback(this_->gra, this_->motion_callback);
3546 callback_destroy(this_->motion_callback); 4015 callback_destroy(this_->motion_callback);
4016 dbg(0,"ex 009\n");
3547 if(this_->gra) 4017 if (this_->gra)
3548 graphics_remove_callback(this_->gra, this_->predraw_callback); 4018 graphics_remove_callback(this_->gra, this_->predraw_callback);
3549 callback_destroy(this_->predraw_callback); 4019 callback_destroy(this_->predraw_callback);
4020 dbg(0,"ex 010\n");
3550 route_destroy(this_->route); 4021 route_destroy(this_->route);
4022 dbg(0,"ex 011\n");
3551 ms = navit_get_mapset(this_); 4023 ms = navit_get_mapset(this_);
4024 dbg(0,"ex 012\n");
3552 if(ms) 4025 if (ms)
3553 mapset_destroy(ms); 4026 mapset_destroy(ms);
4027 dbg(0,"ex 013\n");
3554 graphics_free(this_->gra); 4028 graphics_free(this_->gra);
4029 dbg(0,"ex 014\n");
3555 g_free(this_); 4030 g_free(this_);
4031 dbg(0,"ex 015\n");
3556} 4032}
3557 4033
3558/** @} */ 4034/** @} */

Legend:
Removed from v.14  
changed lines
  Added in v.27

   
Visit the ZANavi Wiki