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

Contents of /navit/navit/android.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 51 - (hide annotations) (download)
Mon Jul 25 19:29:08 2016 UTC (4 years, 8 months ago) by zoff99
File MIME type: text/plain
File size: 105464 byte(s)
v2.0.52
1 zoff99 27 /**
2     * ZANavi, Zoff Android Navigation system.
3 zoff99 40 * Copyright (C) 2011-2014 Zoff <zoff@zoff.cc>
4 zoff99 27 *
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    
20 zoff99 2 #include <stdlib.h>
21     #include <string.h>
22     #include <poll.h>
23     #include <glib.h>
24     #include "android.h"
25     #include <android/log.h>
26 zoff99 40 #include <android/bitmap.h>
27 zoff99 2 #include "navit.h"
28     #include "config_.h"
29     #include "command.h"
30     #include "debug.h"
31     #include "event.h"
32     #include "callback.h"
33     #include "projection.h"
34     #include "map.h"
35     #include "transform.h"
36     #include "color.h"
37     #include "types.h"
38     #include "search.h"
39     #include "start_real.h"
40     #include "route.h"
41 zoff99 40 #include "track.h"
42 zoff99 27 #include "file.h"
43 zoff99 40 #include "roadprofile.h"
44 zoff99 34 #include "navit_nls.h"
45 zoff99 2
46     // #include "layout.h"
47    
48     JNIEnv *jnienv;
49     jobject *android_activity;
50 zoff99 40 jobject *main_map_bitmap;
51     AndroidBitmapInfo *main_map_bitmapinfo;
52 zoff99 2 struct callback_list *android_activity_cbl;
53     int android_version;
54    
55 zoff99 27 jclass NavitGraphicsClass2 = NULL;
56 zoff99 2 jmethodID return_generic_int;
57 zoff99 27 jmethodID send_generic_text;
58     jclass NavitMapPreviewActivityClass = NULL;
59 zoff99 2 jmethodID DrawMapPreview_target;
60 zoff99 27 jmethodID DrawMapPreview_polyline = NULL;
61 zoff99 50 jmethodID DrawPreview_polyline = NULL;
62 zoff99 27 jmethodID DrawMapPreview_text = NULL;
63 zoff99 30 jmethodID NavitGraphics_send_osd_values2 = NULL;
64     jmethodID NavitGraphics_set_vehicle_values2 = NULL;
65     jmethodID NavitGraphics_set_vehicle_values3 = NULL;
66 zoff99 31 jmethodID NavitGraphics_send_route_rect_to_java = NULL;
67 zoff99 2
68     struct attr attr;
69    
70 zoff99 40
71    
72    
73    
74    
75    
76     // #define NAVIT_FUNC_CALLS_DEBUG_PRINT 1
77    
78    
79     // --------------- debug function calls ------------------
80     // --------------- debug function calls ------------------
81     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
82     #undef return2
83     #define return2 dbg_func(0, global_func_indent_counter, "return(%d)\n", __LINE__);global_func_indent_counter--;return
84    
85     #define __F_START__ global_func_indent_counter++;dbg_func(0, global_func_indent_counter, "enter\n");
86     #define __F_END__ dbg_func(0, global_func_indent_counter, "leave\n");global_func_indent_counter--;
87     #else
88     #undef return2
89     #define return2 return
90    
91     #define __F_START__
92     #define __F_END__
93     #endif
94     // --------------- debug function calls ------------------
95     // --------------- debug function calls ------------------
96    
97    
98    
99    
100    
101    
102    
103    
104    
105    
106 zoff99 28 // ------------------------- COPIED STUFF --- this is generally bad ------------------
107     // ------------------------- COPIED STUFF --- this is generally bad ------------------
108     // ------------------------- COPIED STUFF --- this is generally bad ------------------
109    
110    
111     // copyied from config_.c !!! (always keep in sync!!!)
112 zoff99 30 struct config
113     {
114 zoff99 27 struct attr **attrs;
115     struct callback_list *cbl;
116 zoff99 30 }*config;
117 zoff99 2
118 zoff99 28 // copied from gui_internal.c (always keep in sync!!!)
119 zoff99 30 struct gui_config_settings
120     {
121     int font_size;
122     int icon_xs;
123     int icon_s;
124     int icon_l;
125     int spacing;
126 zoff99 2 };
127    
128 zoff99 28 // dummy def!!
129 zoff99 30 struct gui_internal_methods
130     {
131 zoff99 2 int dummy;
132     };
133    
134 zoff99 28 // dummy def!!
135 zoff99 30 struct gui_internal_widget_methods
136     {
137 zoff99 2 int dummy;
138     };
139    
140 zoff99 28 // forward def
141     struct gui_priv;
142    
143     // copied from gui_internal.h (always keep in sync!!!)
144 zoff99 30 struct gui_internal_data
145     {
146 zoff99 28 struct gui_priv *priv;
147     struct gui_internal_methods *gui;
148     struct gui_internal_widget_methods *widget;
149 zoff99 2 };
150    
151 zoff99 28 // copied from gui_internal.c (always keep in sync!!!)
152 zoff99 30 struct route_data
153     {
154     struct widget * route_table;
155     int route_showing;
156 zoff99 28
157     };
158    
159     // copied from gui_internal.h (always keep in sync!!!)
160 zoff99 30 enum flags
161     {
162     gravity_none = 0x00, gravity_left = 1, gravity_xcenter = 2, gravity_right = 4, gravity_top = 8, gravity_ycenter = 16, gravity_bottom = 32, gravity_left_top = gravity_left | gravity_top, gravity_top_center = gravity_xcenter | gravity_top, gravity_right_top = gravity_right | gravity_top, gravity_left_center = gravity_left | gravity_ycenter, gravity_center = gravity_xcenter | gravity_ycenter, gravity_right_center = gravity_right | gravity_ycenter, gravity_left_bottom = gravity_left | gravity_bottom, gravity_bottom_center = gravity_xcenter | gravity_bottom, gravity_right_bottom = gravity_right | gravity_bottom, flags_expand = 0x100, flags_fill = 0x200, orientation_horizontal = 0x10000, orientation_vertical = 0x20000, orientation_horizontal_vertical = 0x40000,
163 zoff99 28 };
164    
165     // copied from gui_internal.h (always keep in sync!!!)
166 zoff99 30 enum widget_type
167     {
168     widget_box = 1, widget_button, widget_label, widget_image, widget_table, widget_table_row
169 zoff99 28 };
170    
171     // copied from gui_internal.c (always keep in sync!!!)
172 zoff99 30 struct widget
173     {
174 zoff99 28 enum widget_type type;
175 zoff99 30 struct graphics_gc *background, *text_background;
176 zoff99 28 struct graphics_gc *foreground_frame;
177     struct graphics_gc *foreground;
178     char *text;
179     struct graphics_image *img;
180     void (*func)(struct gui_priv *priv, struct widget *widget, void *data);
181     int reason;
182     int datai;
183     void *data;
184     void (*data_free)(void *data);
185 zoff99 30 void (*free)(struct gui_priv *this_, struct widget * w);
186 zoff99 28 char *prefix;
187     char *name;
188     char *speech;
189     char *command;
190     struct pcoord c;
191     struct item item;
192     int selection_id;
193     int state;
194     struct point p;
195 zoff99 30 int wmin, hmin;
196     int w, h;
197     int textw, texth;
198 zoff99 28 int font_idx;
199 zoff99 30 int bl, br, bt, bb, spx, spy;
200 zoff99 28 int border;
201     int packed;
202     int cols;
203     enum flags flags;
204     int flags2;
205     void *instance;
206     int (*set_attr)(void *, struct attr *);
207     int (*get_attr)(void *, enum attr_type, struct attr *, struct attr_iter *);
208     void (*remove_cb)(void *, struct callback *cb);
209     struct callback *cb;
210     struct attr on;
211     struct attr off;
212     int deflt;
213     int is_on;
214     int redraw;
215     struct menu_data *menu_data;
216     struct form *form;
217     GList *children;
218     };
219    
220     // copied from gui_internal.c !!!!!! (always keep in sync!!!)
221 zoff99 30 struct gui_priv
222     {
223 zoff99 2 struct navit *nav;
224     struct attr self;
225     struct window *win;
226     struct graphics *gra;
227     struct graphics_gc *background;
228     struct graphics_gc *background2;
229     struct graphics_gc *highlight_background;
230     struct graphics_gc *foreground;
231     struct graphics_gc *text_foreground;
232     struct graphics_gc *text_background;
233     struct color background_color, background2_color, text_foreground_color, text_background_color;
234     int spacing;
235     int font_size;
236     int fullscreen;
237     struct graphics_font *fonts[3];
238     int icon_xs;
239     int icon_s;
240     int icon_l;
241     int pressed;
242     struct widget *widgets;
243     int widgets_count;
244     int redraw;
245     struct widget root;
246 zoff99 30 struct widget *highlighted, *editable;
247 zoff99 2 struct widget *highlighted_menu;
248     int clickp_valid, vehicle_valid;
249     struct pcoord clickp, vehiclep;
250     struct attr *click_coord_geo, *position_coord_geo;
251     struct search_list *sl;
252     int ignore_button;
253     int menu_on_map_click;
254     int signal_on_map_click;
255     char *country_iso2;
256     int speech;
257     int keyboard;
258     int keyboard_required;
259 zoff99 27 struct gui_config_settings config;
260 zoff99 2 struct event_idle *idle;
261 zoff99 30 struct callback *motion_cb, *button_cb, *resize_cb, *keypress_cb, *window_closed_cb, *idle_cb, *motion_timeout_callback;
262 zoff99 2 struct event_timeout *motion_timeout_event;
263     struct point current;
264     struct callback * vehicle_cb;
265     struct route_data route_data;
266     struct gui_internal_data data;
267     struct callback_list *cbl;
268     int flags;
269     int cols;
270     struct attr osd_configuration;
271     int pitch;
272 zoff99 30 int flags_town, flags_street, flags_house_number;
273 zoff99 2 int radius;
274     char *html_text;
275     int html_depth;
276     struct widget *html_container;
277     int html_skip;
278     char *html_anchor;
279     char *href;
280     int html_anchor_found;
281     struct form *form;
282 zoff99 30 struct html
283     {
284 zoff99 2 int skip;
285 zoff99 30 enum html_tag
286     {
287     html_tag_none, html_tag_a, html_tag_h1, html_tag_html, html_tag_img, html_tag_script, html_tag_form, html_tag_input, html_tag_div,
288 zoff99 2 } tag;
289     char *command;
290     char *name;
291     char *href;
292     char *refresh_cond;
293     struct widget *w;
294     struct widget *container;
295     } html[10];
296     };
297    
298 zoff99 50
299     // copied from graphics_android.c !!!!!! (always keep in sync!!!)
300     struct graphics_priv
301     {
302     jclass NavitGraphicsClass;
303     jmethodID NavitGraphics_draw_polyline, NavitGraphics_draw_polyline2, NavitGraphics_draw_polyline3, NavitGraphics_draw_polyline4, NavitGraphics_draw_polyline_dashed, NavitGraphics_set_dashes, NavitGraphics_draw_polygon, NavitGraphics_draw_polygon2, NavitGraphics_draw_rectangle, NavitGraphics_draw_circle, NavitGraphics_draw_text, NavitGraphics_draw_image,
304     NavitGraphics_draw_bigmap, NavitGraphics_draw_image_warp, NavitGraphics_draw_mode, NavitGraphics_draw_drag, NavitGraphics_overlay_disable, NavitGraphics_overlay_resize, NavitGraphics_SetCamera, NavitGraphicsClass_rotate_and_scale_bitmap;
305    
306     jclass PaintClass;
307     jmethodID Paint_init, Paint_setStrokeWidth, Paint_setARGB;
308    
309     jobject NavitGraphics;
310     jobject Paint;
311    
312     jclass BitmapFactoryClass;
313     jmethodID BitmapFactory_decodeFile, BitmapFactory_decodeResource;
314    
315     jclass BitmapClass;
316     jmethodID Bitmap_getHeight, Bitmap_getWidth;
317    
318     jclass ContextClass;
319     jmethodID Context_getResources;
320    
321     jclass ResourcesClass;
322     jobject Resources;
323     jmethodID Resources_getIdentifier;
324    
325     };
326    
327     // copied from graphics.c !!!!!! (always keep in sync!!!)
328     struct graphics
329     {
330     struct graphics_priv *priv;
331     };
332    
333    
334 zoff99 28 // ------------------------- COPIED STUFF --- this is generally bad ------------------
335     // ------------------------- COPIED STUFF --- this is generally bad ------------------
336     // ------------------------- COPIED STUFF --- this is generally bad ------------------
337    
338    
339 zoff99 29 JavaVM *cachedJVM = NULL;
340 zoff99 28
341 zoff99 29 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved)
342     {
343 zoff99 30 JNIEnv *env_this;
344     cachedJVM = jvm;
345     if ((*jvm)->GetEnv(jvm, (void**) &env_this, JNI_VERSION_1_6))
346 zoff99 29 {
347 zoff99 30 // dbg(0,"Could not get JVM\n");
348     return JNI_ERR;
349     }
350 zoff99 28
351 zoff99 30 // dbg(0,"++ Found JVM ++\n");
352     return JNI_VERSION_1_6;
353 zoff99 29 }
354 zoff99 28
355 zoff99 29 JNIEnv* jni_getenv()
356     {
357 zoff99 30 JNIEnv* env_this;
358     (*cachedJVM)->GetEnv(cachedJVM, (void**) &env_this, JNI_VERSION_1_6);
359     return env_this;
360 zoff99 29 }
361    
362 zoff99 27 static void gui_internal_search_list_set_default_country2(struct gui_priv *this)
363 zoff99 2 {
364 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
365 zoff99 40 dbg(0,"+#+:enter\n");
366 zoff99 28 #endif
367 zoff99 2 struct attr search_attr, country_name, country_iso2, *country_attr;
368     struct item *item;
369     struct country_search *cs;
370     struct tracking *tracking;
371     struct search_list_result *res;
372    
373 zoff99 30 ////DBG // dbg(0,"### 1");
374 zoff99 2
375 zoff99 27 country_attr = country_default();
376     tracking = navit_get_tracking(this->nav);
377 zoff99 2
378     if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL))
379 zoff99 27 country_attr = &search_attr;
380     if (country_attr)
381     {
382 zoff99 30 ////DBG // dbg(0,"### 2");
383 zoff99 27 cs = country_search_new(country_attr, 0);
384     item = country_search_get_item(cs);
385     if (item && item_attr_get(item, attr_country_name, &country_name))
386     {
387     search_attr.type = attr_country_all;
388 zoff99 30 ////DBG // dbg(0,"country %s\n", country_name.u.str);
389 zoff99 27 search_attr.u.str = country_name.u.str;
390 zoff99 2 search_list_search(this->sl, &search_attr, 0);
391 zoff99 27 while ((res = search_list_get_result(this->sl)))
392     ;
393     if (this->country_iso2)
394 zoff99 2 {
395     // this seems to cause a crash, no idea why
396     //g_free(this->country_iso2);
397 zoff99 27 this->country_iso2 = NULL;
398 zoff99 2 }
399     if (item_attr_get(item, attr_country_iso2, &country_iso2))
400     {
401 zoff99 27 this->country_iso2 = g_strdup(country_iso2.u.str);
402 zoff99 2 }
403     }
404     country_search_destroy(cs);
405 zoff99 27 }
406     else
407     {
408 zoff99 30 //DBG // dbg(0, "warning: no default country found\n");
409 zoff99 27 if (this->country_iso2)
410     {
411 zoff99 30 //DBG // dbg(0, "attempting to use country '%s'\n", this->country_iso2);
412 zoff99 27 search_attr.type = attr_country_iso2;
413     search_attr.u.str = this->country_iso2;
414     search_list_search(this->sl, &search_attr, 0);
415     while ((res = search_list_get_result(this->sl)))
416     ;
417 zoff99 2 }
418     }
419 zoff99 30 ////DBG // dbg(0,"### 99");
420 zoff99 2 }
421    
422 zoff99 30 // forward rev
423 zoff99 2 struct navit *global_navit;
424    
425 zoff99 27 int android_find_class_global(char *name, jclass *ret)
426 zoff99 2 {
427 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
428 zoff99 40 dbg(0,"+#+:enter\n");
429 zoff99 28 #endif
430 zoff99 30
431     JNIEnv *jnienv2;
432     jnienv2 = jni_getenv();
433    
434     *ret = (*jnienv2)->FindClass(jnienv2, name);
435 zoff99 27 if (!*ret)
436     {
437 zoff99 30 //DBG // dbg(0, "Failed to get Class %s\n", name);
438 zoff99 2 return 0;
439     }
440 zoff99 30 //DBG // dbg(0,"lclass %p\n", *ret);
441     *ret = (*jnienv2)->NewGlobalRef(jnienv2, *ret);
442     // ICS (*jnienv2)->DeleteGlobalRef(jnienv2, *lret);
443     //DBG // dbg(0,"gclass %p\n", *ret);
444 zoff99 2 return 1;
445     }
446    
447 zoff99 27 int android_find_method(jclass class, char *name, char *args, jmethodID *ret)
448 zoff99 2 {
449 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
450 zoff99 40 dbg(0,"+#+:enter\n");
451 zoff99 28 #endif
452 zoff99 30
453     JNIEnv *jnienv2;
454     jnienv2 = jni_getenv();
455    
456     *ret = (*jnienv2)->GetMethodID(jnienv2, class, name, args);
457 zoff99 27 if (*ret == NULL)
458     {
459 zoff99 30 //DBG // dbg(0, "Failed to get Method %s with signature %s\n", name, args);
460 zoff99 2 return 0;
461     }
462 zoff99 30 //DBG // dbg(0,"l meth %p\n", *ret);
463 zoff99 2 return 1;
464     }
465    
466 zoff99 27 int android_find_static_method(jclass class, char *name, char *args, jmethodID *ret)
467 zoff99 2 {
468 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
469 zoff99 40 dbg(0,"+#+:enter\n");
470 zoff99 28 #endif
471 zoff99 30
472     JNIEnv *jnienv2;
473     jnienv2 = jni_getenv();
474    
475     *ret = (*jnienv2)->GetStaticMethodID(jnienv2, class, name, args);
476 zoff99 27 if (*ret == NULL)
477     {
478 zoff99 30 //DBG // dbg(0, "Failed to get static Method %s with signature %s\n", name, args);
479 zoff99 2 return 0;
480     }
481 zoff99 30 //DBG // dbg(0,"l meth %p\n", *ret);
482 zoff99 2 return 1;
483     }
484    
485 zoff99 40
486 zoff99 2 JNIEXPORT void JNICALL
487 zoff99 40 Java_com_zoffcc_applications_zanavi_Navit_NavitMain(JNIEnv* env, jobject thiz, jobject activity, jobject lang, int version, jobject display_density_string, jobject n_datadir, jobject n_sharedir, jobject bitmap)
488 zoff99 2 {
489 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
490 zoff99 40 dbg(0,"+#+:enter\n");
491 zoff99 28 #endif
492 zoff99 30
493 zoff99 31 #ifdef DEBUG_GLIB_MEM_FUNCTIONS
494     // GLIB debugging
495     // GLIB debugging
496     // GLIB debugging
497 zoff99 34 /*
498     dbg(0,"GLIB debugging ----------------------");
499     dbg(0,"GLIB debugging ----------------------");
500     dbg(0,"GLIB debugging ----------------------");
501     dbg(0,"GLIB debugging ----------------------");
502     dbg(0,"GLIB debugging ----------------------");
503     dbg(0,"GLIB debugging ----------------------");
504     dbg(0,"GLIB debugging ----------------------");
505     dbg(0,"GLIB debugging ----------------------");
506     dbg(0,"GLIB debugging 1 --------------------");
507     */
508     //*******???******** g_mem_set_vtable(glib_mem_profiler_table);
509 zoff99 31 //char *dummy_997;
510     //dummy_997 = g_malloc(1024*1024*10); // 10 MByte
511     //g_free(dummy_997);
512     //dummy_997 = NULL;
513     //g_mem_profile();
514 zoff99 34 /*
515     dbg(0,"GLIB debugging 2 --------------------");
516     dbg(0,"GLIB debugging ----------------------");
517     dbg(0,"GLIB debugging ----------------------");
518     dbg(0,"GLIB debugging ----------------------");
519     dbg(0,"GLIB debugging ----------------------");
520     dbg(0,"GLIB debugging ----------------------");
521     dbg(0,"GLIB debugging ----------------------");
522     dbg(0,"GLIB debugging ----------------------");
523     dbg(0,"GLIB debugging ----------------------");
524     */
525 zoff99 31 // GLIB debugging
526     // GLIB debugging
527     // GLIB debugging
528     #endif
529    
530 zoff99 30 int thread_id = gettid();
531     // dbg(0, "THREAD ID=%d\n", thread_id);
532    
533     char *strings[] = { "/data/data/com.zoffcc.applications.zanavi/bin/navit", NULL };
534 zoff99 2 const char *langstr;
535     const char *displaydensitystr;
536 zoff99 34 const char *s;
537 zoff99 27 android_version = version;
538 zoff99 2 //__android_log_print(ANDROID_LOG_ERROR,"test","called");
539 zoff99 40 android_activity_cbl = callback_list_new("Java_com_zoffcc_applications_zanavi_Navit_NavitMain:android_activity_cbl");
540 zoff99 27
541 zoff99 30 // SET GLOBAL JNIENV here, this is bad!!
542     // SET GLOBAL JNIENV here, this is bad!!
543     // SET GLOBAL JNIENV here, this is bad!!
544 zoff99 27 jnienv = env;
545 zoff99 30 // dbg(0,"jnienv=%p\n", env);
546     // SET GLOBAL JNIENV here, this is bad!!
547     // SET GLOBAL JNIENV here, this is bad!!
548     // SET GLOBAL JNIENV here, this is bad!!
549 zoff99 27
550     //jclass someClass = env->FindClass("SomeClass");
551     //gSomeClass = env->NewGlobalRef(someClass);
552    
553    
554 zoff99 40
555     #if 0
556     // runtime TEST INT / FLOAT ----------
557     // runtime TEST INT / FLOAT ----------
558     // runtime TEST INT / FLOAT ----------
559     int v1 = 27;
560     int v2 = 13;
561     int r2;
562     int r3;
563    
564     int ij1a;
565     int ccc = 10000000;
566     clock_t s_;
567    
568     s_ = debug_measure_start();
569     for (ij1a=0; ij1a < ccc; ij1a++)
570     {
571     r2 = ( v1 * 100 * (v2 * 10.0 ) / 10000);
572     }
573     debug_mrp("TEST:INT :", debug_measure_end(s_));
574    
575     s_ = debug_measure_start();
576     for (ij1a=0; ij1a < ccc; ij1a++)
577     {
578     r3 = (int)( (float)v1 * ((float)v2 / 10.0f ));
579     }
580     debug_mrp("TEST:FLOAT:", debug_measure_end(s_));
581     // runtime TEST INT / FLOAT ----------
582     // runtime TEST INT / FLOAT ----------
583     // runtime TEST INT / FLOAT ----------
584     #endif
585    
586    
587    
588     main_map_bitmap = (*env)->NewGlobalRef(env, bitmap); // --> ANDROID_BITMAP_FORMAT_RGBA_8888
589     main_map_bitmapinfo = NULL;
590    
591     // enum AndroidBitmapFormat {
592     // ANDROID_BITMAP_FORMAT_NONE = 0,
593     // ANDROID_BITMAP_FORMAT_RGBA_8888 = 1,
594     // ANDROID_BITMAP_FORMAT_RGB_565 = 4,
595     // ANDROID_BITMAP_FORMAT_RGBA_4444 = 7,
596     // ANDROID_BITMAP_FORMAT_A_8 = 8,
597     // };
598    
599    
600 zoff99 27 // *only local* android_activity = activity;
601     // android_activity = (*jnienv)->NewGlobalRef(jnienv, activity);
602     android_activity = (*env)->NewGlobalRef(env, activity);
603     langstr = (*env)->GetStringUTFChars(env, lang, NULL);
604 zoff99 30 //DBG // dbg(0, "enter env=%p thiz=%p activity=%p lang=%s version=%d\n", env, thiz, activity, langstr, version);
605     //DBG // dbg(0, "enter env=%p thiz=%p activity=%p lang=%s version=%d\n", env, thiz, android_activity, langstr, version);
606 zoff99 27 setenv("LANG", langstr, 1);
607 zoff99 2 (*env)->ReleaseStringUTFChars(env, lang, langstr);
608    
609 zoff99 34 s = (*env)->GetStringUTFChars(env, n_datadir, NULL);
610     navit_data_dir = g_strdup(s);
611     (*env)->ReleaseStringUTFChars(env, n_datadir, s);
612    
613     s = (*env)->GetStringUTFChars(env, n_sharedir, NULL);
614     navit_share_dir = g_strdup(s);
615     (*env)->ReleaseStringUTFChars(env, n_sharedir, s);
616    
617    
618 zoff99 27 displaydensitystr = (*env)->GetStringUTFChars(env, display_density_string, NULL);
619 zoff99 34 dbg(0, "*****displaydensity=%s\n", displaydensitystr);
620 zoff99 27 setenv("ANDROID_DENSITY", displaydensitystr, 1);
621 zoff99 34
622     // calc DPI value
623     global_have_dpi_value = atoi(displaydensitystr);
624     dbg(0, "*****displaydensity int=%d\n", (int) global_have_dpi_value);
625    
626     if (global_have_dpi_value >= 320)
627     {
628     global_dpi_factor = (float) global_have_dpi_value / 240.0f; // multiply with this factor where needed!
629     }
630     else
631     {
632     global_dpi_factor = 1.0f;
633     }
634    
635 zoff99 2 (*env)->ReleaseStringUTFChars(env, display_density_string, displaydensitystr);
636 zoff99 28
637 zoff99 30 //// dbg(0,"before main_real call\n");
638     //main_real(1, strings);
639     //// dbg(0,"after main_real call\n");
640 zoff99 28
641 zoff99 31 /* -- mem test --
642     char *dummy_99;
643     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
644     g_free(dummy_99);
645     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
646     g_free(dummy_99);
647     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
648     g_free(dummy_99);
649     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
650     g_free(dummy_99);
651     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
652     g_free(dummy_99);
653     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
654     g_free(dummy_99);
655     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
656     g_free(dummy_99);
657     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
658     g_free(dummy_99);
659     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
660     g_free(dummy_99);
661     dummy_99 = g_malloc(1024*1024*10); // 10 MByte
662     g_free(dummy_99);
663     dummy_997 = NULL;
664     */
665    
666 zoff99 41
667    
668     #if 0
669    
670     double lat = 48.6936931;
671     double lon = 16.0135909;
672     float latf = 48.6936931;
673     float lonf = 16.0135909;
674    
675    
676     //transform_to_geo_lat(transform_from_geo_lat(lat));
677     //transform_to_geo_lon(transform_from_geo_lon(lon));
678    
679    
680     long long j=0;
681     double ddd;
682     int in_y=12278278;
683    
684     clock_t s_;
685     clock_t diff_time;
686    
687     s_ = clock();
688     for(j=0;j<10000000L;j++)
689     {
690     ddd = atan(exp((in_y/2.00) / 6378137.0)) / M_PI * 360 - 90;
691     }
692     diff_time = clock() - s_;
693     dbg(0, "1:%fs\n", (double) ((double) diff_time / (double) CLOCKS_PER_SEC));
694    
695     s_ = clock();
696     for(j=0;j<10000000L;j++)
697     {
698     ddd = TO_GEO_LAT_(in_y);
699     // fprintf(stderr, "lon=%.17f\n", ddd);
700     }
701     diff_time = clock() - s_;
702     dbg(0, "2:%fs\n", (double) ((double) diff_time / (double) CLOCKS_PER_SEC));
703    
704     s_ = clock();
705     for(j=0;j<10000000L;j++)
706     {
707     ddd = TO_GEO_LAT_FAST_(in_y);
708     }
709     diff_time = clock() - s_;
710     dbg(0, "3:%fs\n", (double) ((double) diff_time / (double) CLOCKS_PER_SEC));
711    
712    
713     #endif
714    
715    
716    
717    
718    
719 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
720 zoff99 40 dbg(0,"+#+:leave\n");
721 zoff99 28 #endif
722    
723 zoff99 2 }
724    
725     JNIEXPORT void JNICALL
726 zoff99 27 Java_com_zoffcc_applications_zanavi_Navit_NavitActivity(JNIEnv* env, jobject thiz, int param)
727 zoff99 2 {
728 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
729 zoff99 40 dbg(0,"+#+:enter\n");
730 zoff99 28 #endif
731 zoff99 2
732 zoff99 40 dbg(0, "enter %d\n", param);
733 zoff99 30
734     int thread_id = gettid();
735     // dbg(0, "THREAD ID=%d\n", thread_id);
736    
737 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
738    
739 zoff99 2 if (param == -2)
740     {
741     // onStop() -> called in Java app
742     // save center.txt
743     if (global_navit->bookmarks)
744     {
745     config_get_attr(config, attr_navit, &attr, NULL);
746 zoff99 30 //DBG // dbg(0, "save position to file");
747 zoff99 2 char *center_file = bookmarks_get_center_file(TRUE);
748     bookmarks_write_center_to_file(attr.u.navit->bookmarks, center_file);
749 zoff99 30 // dbg(0, "save pos to file -> ready");
750 zoff99 2 g_free(center_file);
751     // bookmarks_destroy(global_navit->bookmarks);
752     }
753     }
754 zoff99 40 #endif
755 zoff99 2
756 zoff99 28 // param == 3 // onCreate
757     // param == 2 // onStart
758     // param == 1 // onResume
759     // param == 0 // onRestart
760     // param == -1 // onPause
761     // param == -2 // onStop
762     // param == -3 // onDestroy
763     // param == -4 // exit() [java function]
764    
765 zoff99 40
766 zoff99 28 if (param == 3)
767 zoff99 2 {
768 zoff99 30 // in onCreate at startup
769     char *strings[] = { "/data/data/com.zoffcc.applications.zanavi/bin/navit", NULL };
770    
771 zoff99 41 // ------------ send initial values for GEO calcs to Java ---------------
772     // ------------ send initial values for GEO calcs to Java ---------------
773     char *temp_t = NULL;
774    
775     temp_t = g_strdup_printf("%.17f\n", (double)__EARTH_RADIUS__);
776     android_send_generic_text(21, temp_t);
777     g_free(temp_t);
778    
779     temp_t = g_strdup_printf("%.17f\n", (double)__GEO_ACCURACY_FACTOR__);
780     android_send_generic_text(22, temp_t);
781     g_free(temp_t);
782    
783     temp_t = NULL;
784     // ------------ send initial values for GEO calcs to Java ---------------
785     // ------------ send initial values for GEO calcs to Java ---------------
786    
787 zoff99 30 // dbg(0,"before main_real call\n");
788     main_real(1, strings);
789     // dbg(0,"after main_real call\n");
790    
791 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
792 zoff99 28 navit_draw(global_navit);
793 zoff99 40 #endif
794 zoff99 2 }
795    
796 zoff99 40
797 zoff99 30 // dbg(0, "acti: 001\n");
798 zoff99 28 // callback_list_call_1(android_activity_cbl, param);
799 zoff99 30 //// dbg(0, "acti: 002\n");
800 zoff99 27
801 zoff99 28 //if (param == -4)
802 zoff99 27 //{
803 zoff99 30 // // dbg(0, "acti: 003\n");
804 zoff99 28 // // *********EXIT******EXIT******** // exit(0);
805 zoff99 27 //}
806    
807 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
808 zoff99 28 if (param == -4)
809     {
810 zoff99 30 // dbg(0, "acti: 004\n");
811 zoff99 28 navit_destroy(global_navit);
812 zoff99 30 // dbg(0, "acti: 005\n");
813 zoff99 28 event_main_loop_quit();
814 zoff99 30 // dbg(0, "acti: 006\n");
815 zoff99 28 }
816 zoff99 40 #endif
817    
818     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
819     dbg(0,"+#+:leave\n");
820     #endif
821 zoff99 2 }
822    
823     JNIEXPORT void JNICALL
824 zoff99 40 Java_com_zoffcc_applications_zanavi_NavitGraphics_SizeChangedCallbackReal(JNIEnv* env, jobject thiz, int w, int h, jobject bitmap)
825 zoff99 2 {
826 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
827 zoff99 40 dbg(0,"+#+:enter\n");
828 zoff99 28 #endif
829 zoff99 30 // dbg(0,"enter %d %d\n", w, h);
830    
831     int thread_id = gettid();
832     // dbg(0, "THREAD ID=%d\n", thread_id);
833    
834 zoff99 40
835     #ifndef NAVIT_DEBUG_BAREMETAL
836    
837     if (main_map_bitmap)
838     {
839     (*env)->DeleteGlobalRef(env, main_map_bitmap);
840     }
841     main_map_bitmap = (*env)->NewGlobalRef(env, bitmap); // --> ANDROID_BITMAP_FORMAT_RGBA_8888
842     main_map_bitmapinfo = NULL;
843    
844 zoff99 28 navit_handle_resize(global_navit, w, h);
845 zoff99 40
846     #endif
847    
848 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
849 zoff99 40 dbg(0,"+#+:leave\n");
850 zoff99 28 #endif
851 zoff99 2 }
852    
853     JNIEXPORT void JNICALL
854 zoff99 34 Java_com_zoffcc_applications_zanavi_NavitGraphics_MotionCallbackReal(JNIEnv* env, jobject thiz, int x1, int y1, int x2, int y2, int draw)
855 zoff99 2 {
856 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
857 zoff99 40 dbg(0,"+#+:enter\n");
858 zoff99 28 #endif
859 zoff99 2
860 zoff99 30 //int thread_id = gettid();
861     // dbg(0, "THREAD ID=%d\n", thread_id);
862    
863 zoff99 40
864     #ifndef NAVIT_DEBUG_BAREMETAL
865    
866 zoff99 28 struct point p_end;
867     struct point p_start;
868    
869     p_start.x = x1;
870     p_start.y = y1;
871     p_end.x = x2;
872     p_end.y = y2;
873     update_transformation(global_navit->trans, &p_start, &p_end, NULL);
874     // graphics_draw_drag(this_->gra, NULL);
875     transform_copy(global_navit->trans, global_navit->trans_cursor);
876     global_navit->moved = 1;
877    
878     /*
879 zoff99 30 struct coord c;
880     struct pcoord pc;
881     p.x = x;
882     p.y = y;
883     transform_reverse(global_navit->trans, &p, &c);
884     pc.x = c.x;
885     pc.y = c.y;
886     pc.pro = transform_get_projection(global_navit->trans);
887     navit_set_position(global_navit, &pc);
888     */
889 zoff99 28
890 zoff99 30 // dbg(0,"call async java draw -start-\n");
891 zoff99 34 if (draw == 1)
892     {
893     navit_draw(global_navit);
894     }
895     else
896     {
897     // if we dont want to draw, then also cancel any drawing that is already in progress!
898     cancel_drawing_global = 1;
899     }
900 zoff99 29 // navit_draw_async(global_navit, 1);
901 zoff99 30 // dbg(0,"call async java draw --end--\n");
902 zoff99 29
903     // remove the "wait" screen
904 zoff99 30 //#ifdef HAVE_API_ANDROID
905     // android_return_generic_int(2, 0);
906     //#endif
907 zoff99 29
908 zoff99 40 #endif
909    
910 zoff99 2 }
911    
912     JNIEXPORT void JNICALL
913 zoff99 30 Java_com_zoffcc_applications_zanavi_NavitGraphics_TimeoutCallback(JNIEnv* env, jobject thiz, int delete, int id)
914 zoff99 2 {
915 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
916 zoff99 40 dbg(0,"+#+:enter\n");
917 zoff99 28 #endif
918 zoff99 30
919 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
920    
921 zoff99 30 JNIEnv *jnienv2;
922     jnienv2 = jni_getenv();
923    
924     //int thread_id = gettid();
925     //dbg(0, "THREAD ID=%d\n", thread_id);
926    
927     //DBG // dbg(0,"enter %p %d %p\n",thiz, delete, (void *)id);
928 zoff99 28 //dbg(0,"timeout 1\n");
929 zoff99 27 // ICS
930 zoff99 30 //if (id != 0)
931     //{
932     // dbg(0,"callback struct=%p %d\n", id, id);
933 zoff99 27 callback_call_0((struct callback *) id);
934 zoff99 30 //}
935 zoff99 27 // ICS
936 zoff99 28 //dbg(0,"timeout 2\n");
937 zoff99 30
938     /*
939     if (delete)
940     {
941     //dbg(0,"timeout 3\n");
942     // ICS
943     jobject this_global = (*jnienv2)->NewGlobalRef(jnienv2, thiz);
944     //dbg(0,"timeout 3.1\n");
945     (*jnienv2)->DeleteGlobalRef(jnienv2, this_global);
946     // ICS
947     //dbg(0,"timeout 4\n");
948     }
949     */
950 zoff99 40 #endif
951 zoff99 2 }
952    
953     JNIEXPORT void JNICALL
954 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitIdle_IdleCallback(JNIEnv* env, jobject thiz, int id)
955 zoff99 2 {
956 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
957 zoff99 40 dbg(0,"+#+:enter\n");
958 zoff99 28 #endif
959 zoff99 30
960     //int thread_id = gettid();
961     // dbg(0, "THREAD ID=%d\n", thread_id);
962    
963     //DBG // dbg(0,"enter %p %p\n",thiz, (void *)id);
964     // dbg(0,"idlecall back 1\n");
965 zoff99 27 callback_call_0((struct callback *) id);
966 zoff99 30 // dbg(0,"idlecall back 2\n");
967 zoff99 2 }
968    
969     JNIEXPORT void JNICALL
970 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitWatch_poll(JNIEnv* env, jobject thiz, int fd, int cond)
971 zoff99 2 {
972 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
973 zoff99 40 dbg(0,"+#+:enter\n");
974 zoff99 28 #endif
975 zoff99 2 struct pollfd pfd;
976 zoff99 27 pfd.fd = fd;
977 zoff99 30 //DBG // dbg(0, "%p poll called for %d %d\n", env, fd, cond);
978 zoff99 27 switch ((enum event_watch_cond) cond)
979     {
980     case event_watch_cond_read:
981     pfd.events = POLLIN;
982     break;
983     case event_watch_cond_write:
984     pfd.events = POLLOUT;
985     break;
986     case event_watch_cond_except:
987     pfd.events = POLLERR;
988     break;
989     default:
990     pfd.events = 0;
991 zoff99 2 }
992 zoff99 27 pfd.revents = 0;
993 zoff99 2 poll(&pfd, 1, -1);
994     }
995    
996     JNIEXPORT void JNICALL
997 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitWatch_WatchCallback(JNIEnv* env, jobject thiz, int id)
998 zoff99 2 {
999 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1000 zoff99 40 dbg(0,"+#+:enter\n");
1001 zoff99 28 #endif
1002 zoff99 30 //DBG // dbg(0, "enter %p %p\n", thiz, (void *) id);
1003 zoff99 27 callback_call_0((struct callback *) id);
1004 zoff99 2 }
1005    
1006     JNIEXPORT void JNICALL
1007 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitSensors_SensorCallback(JNIEnv* env, jobject thiz, int id, int sensor, float x, float y, float z)
1008 zoff99 2 {
1009 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1010 zoff99 40 dbg(0,"+#+:enter\n");
1011 zoff99 28 #endif
1012 zoff99 30 // JNIEnv *jnienv2;
1013     // jnienv2 = jni_getenv();
1014    
1015     //int thread_id = gettid();
1016     // dbg(0, "THREAD ID=%d\n", thread_id);
1017    
1018     //DBG // dbg(0, "enter %p %p %f %f %f\n", thiz, (void *) id, x, y, z);
1019 zoff99 27 callback_call_4((struct callback *) id, sensor, &x, &y, &z);
1020 zoff99 2 }
1021    
1022 zoff99 28 JNIEXPORT void JNICALL
1023 zoff99 34 Java_com_zoffcc_applications_zanavi_NavitVehicle_VehicleCallback(JNIEnv *env, jobject thiz, double lat, double lon, float speed, float direction, double height, float radius, long gpstime)
1024 zoff99 28 {
1025     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1026 zoff99 40 dbg(0,"+#+:enter\n");
1027 zoff99 28 #endif
1028    
1029 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
1030    
1031 zoff99 30 // JNIEnv *jnienv2;
1032     // jnienv2 = jni_getenv();
1033     //int thread_id = gettid();
1034     //dbg(0, "THREAD ID=%d\n", thread_id);
1035 zoff99 28
1036 zoff99 30 //dbg(0,"VehicleCallback location=%p\n", location);
1037 zoff99 34 //+++jobject location2 = (*env)->NewGlobalRef(env, location);
1038     //+++(*env)->DeleteLocalRef(env, location);
1039 zoff99 30 //// dbg(0,"location=%p\n", location2);
1040    
1041     if ((global_navit) && (global_navit->vehicle) && (global_navit->vehicle->vehicle))
1042     {
1043 zoff99 34 vehicle_update_(global_navit->vehicle->vehicle, lat, lon, speed, direction, height, radius, gpstime);
1044 zoff99 30 }
1045     else
1046     {
1047     dbg(0, "no vehicle set !!\n");
1048     }
1049    
1050 zoff99 40 #endif
1051    
1052 zoff99 30 //dbg(0,"leave\n");
1053    
1054 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1055 zoff99 40 dbg(0,"+#+:leave\n");
1056 zoff99 28 #endif
1057     }
1058    
1059 zoff99 27 void android_return_search_result(struct jni_object *jni_o, char *str)
1060 zoff99 2 {
1061 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1062 zoff99 40 dbg(0,"+#+:enter\n");
1063 zoff99 28 #endif
1064 zoff99 31 // dbg(0,"EEnter\n");
1065 zoff99 30
1066     // int thread_id = gettid();
1067     // dbg(0, "THREAD ID=%d\n", thread_id);
1068    
1069 zoff99 2 jstring js2 = NULL;
1070     JNIEnv* env2;
1071 zoff99 27 env2 = jni_o->env;
1072     js2 = (*env2)->NewStringUTF(jni_o->env, str);
1073 zoff99 2 (*env2)->CallVoidMethod(jni_o->env, jni_o->jo, jni_o->jm, js2);
1074     (*env2)->DeleteLocalRef(jni_o->env, js2);
1075     }
1076    
1077 zoff99 27 void android_return_generic_int(int id, int i)
1078 zoff99 2 {
1079 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1080 zoff99 40 dbg(0,"+#+:enter\n");
1081 zoff99 28 #endif
1082 zoff99 30 //DBG // dbg(0,"Enter\n");
1083 zoff99 29
1084 zoff99 30 // int thread_id = gettid();
1085     // dbg(0, "THREAD ID=%d\n", thread_id);
1086    
1087 zoff99 29 JNIEnv *jnienv2;
1088     jnienv2 = jni_getenv();
1089    
1090 zoff99 50
1091 zoff99 2 if (NavitGraphicsClass2 == NULL)
1092     {
1093     if (!android_find_class_global("com/zoffcc/applications/zanavi/NavitGraphics", &NavitGraphicsClass2))
1094     {
1095 zoff99 27 NavitGraphicsClass2 = NULL;
1096 zoff99 2 return;
1097     }
1098     }
1099 zoff99 30 //DBG // dbg(0,"xx1\n");
1100 zoff99 2 if (return_generic_int == NULL)
1101     {
1102 zoff99 27 android_find_static_method(NavitGraphicsClass2, "return_generic_int", "(II)V", &return_generic_int);
1103 zoff99 2 }
1104 zoff99 30 //DBG // dbg(0,"xx2\n");
1105 zoff99 2 if (return_generic_int == NULL)
1106     {
1107 zoff99 30 //DBG // dbg(0, "no method found\n");
1108 zoff99 2 return; /* exception thrown */
1109     }
1110 zoff99 30 //DBG // dbg(0,"xa1\n");
1111 zoff99 29 // -crash- (*jnienv2)->CallVoidMethod(jnienv2, NavitGraphicsClass2, return_generic_int, id, i);
1112     (*jnienv2)->CallStaticVoidMethod(jnienv2, NavitGraphicsClass2, return_generic_int, id, i);
1113     // -works- (*jnienv2)->CallStaticObjectMethod(jnienv2, NavitGraphicsClass2, return_generic_int, id, i);
1114 zoff99 30 //DBG // dbg(0,"xa2\n");
1115 zoff99 2 }
1116    
1117     JNIEXPORT void JNICALL
1118 zoff99 31 Java_com_zoffcc_applications_zanavi_NavitGraphics_CallbackSearchResultList(JNIEnv* env, jobject thiz, int id, int partial, jobject str, jobject str_town, jobject str_hn, int search_flags, jobject search_country, jobject latlon, int radius)
1119 zoff99 2 {
1120 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1121 zoff99 40 dbg(0,"+#+:enter\n");
1122 zoff99 28 #endif
1123 zoff99 30
1124     int thread_id = gettid();
1125     // dbg(0, "THREAD ID=%d\n", thread_id);
1126    
1127 zoff99 2 const char *s;
1128 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
1129 zoff99 30 ////DBG // dbg(0,"*****string=%s\n",s);
1130 zoff99 2
1131    
1132     config_get_attr(config, attr_navit, &attr, NULL);
1133     // attr.u.navit
1134    
1135     jstring js2 = NULL;
1136 zoff99 27 jclass cls_local = (*env)->GetObjectClass(env, thiz);
1137    
1138     // ICS ???
1139     jclass cls = (*env)->NewGlobalRef(env, cls_local);
1140     // ICS ???
1141    
1142 zoff99 2 jmethodID aMethodID = (*env)->GetMethodID(env, cls, "fillStringArray", "(Ljava/lang/String;)V");
1143 zoff99 27 if (aMethodID == 0)
1144 zoff99 2 {
1145 zoff99 30 ////DBG // dbg(0,"**** Unable to get methodID: fillStringArray");
1146 zoff99 2 return;
1147     }
1148    
1149     if (id)
1150     {
1151     // search for town in variable "s" within current country -> return a list of towns as result
1152 zoff99 27 if (id == 1)
1153 zoff99 2 {
1154     // unused now!!
1155     }
1156 zoff99 31 // new experimental street-index search
1157 zoff99 2 else if (id == 2)
1158     {
1159 zoff99 31 offline_search_break_searching = 0;
1160    
1161     struct jni_object my_jni_object;
1162     my_jni_object.env = env;
1163     my_jni_object.jo = thiz;
1164     my_jni_object.jm = aMethodID;
1165    
1166     const char *s_town;
1167     s_town = (*env)->GetStringUTFChars(env, str_town, NULL);
1168     const char *s_hn;
1169     s_hn = (*env)->GetStringUTFChars(env, str_hn, NULL);
1170    
1171     search_v2(s, s_town, s_hn, partial, &my_jni_object);
1172    
1173     (*env)->ReleaseStringUTFChars(env, str_town, s_town);
1174     (*env)->ReleaseStringUTFChars(env, str_hn, s_hn);
1175    
1176     }
1177     // search for street in variable "s" within "search_country" -> return a list of streets as result
1178 zoff99 50 // ------- normal search ----------
1179     // ------- normal search ----------
1180     // ------- normal search ----------
1181     // ------- normal search ----------
1182     // ------- normal search ----------
1183     // ------- normal search ----------
1184 zoff99 31 else if (id == 29)
1185     {
1186 zoff99 2 //struct attr s_attr4;
1187     //struct gui_priv *gp4;
1188     //struct gui_priv gp_24;
1189    
1190 zoff99 15 offline_search_break_searching = 0;
1191 zoff99 2
1192     struct jni_object my_jni_object;
1193 zoff99 27 my_jni_object.env = env;
1194     my_jni_object.jo = thiz;
1195     my_jni_object.jm = aMethodID;
1196 zoff99 2
1197     //gp4=&gp_24;
1198     //gp4->nav=attr.u.navit;
1199 zoff99 27 struct mapset *ms4 = navit_get_mapset(attr.u.navit);
1200     GList *ret = NULL;
1201     int flags = search_flags;
1202     char *search_country_string = (*env)->GetStringUTFChars(env, search_country, NULL);
1203     ret = search_by_address(ret, ms4, s, partial, &my_jni_object, flags, search_country_string);
1204 zoff99 2 (*env)->ReleaseStringUTFChars(env, search_country, search_country_string);
1205    
1206     // free the memory
1207     g_list_free(ret);
1208 zoff99 30 ////DBG // dbg(0,"ret=%p\n",ret);
1209 zoff99 2
1210    
1211     //if (gp4->sl)
1212     //{
1213     // //search_list_destroy(gp4->sl);
1214     // gp4->sl=NULL;
1215     //}
1216     }
1217     // do a full search in all mapfiles for string in variable "s" -> return a list of streets as result
1218     else if (id == 3)
1219     {
1220     const char *s3;
1221 zoff99 27 s3 = (*env)->GetStringUTFChars(env, latlon, NULL);
1222 zoff99 2 char parse_str[strlen(s3) + 1];
1223     strcpy(parse_str, s3);
1224     (*env)->ReleaseStringUTFChars(env, latlon, s3);
1225    
1226     struct coord_geo g7;
1227     char *p;
1228     char *stopstring;
1229    
1230     // lat
1231 zoff99 27 p = strtok(parse_str, "#");
1232 zoff99 2 g7.lat = strtof(p, &stopstring);
1233     // lon
1234 zoff99 27 p = strtok(NULL, "#");
1235 zoff99 2 g7.lng = strtof(p, &stopstring);
1236    
1237     struct jni_object my_jni_object;
1238 zoff99 27 my_jni_object.env = env;
1239     my_jni_object.jo = thiz;
1240     my_jni_object.jm = aMethodID;
1241 zoff99 28
1242     offline_search_break_searching = 0;
1243    
1244 zoff99 2 // search_flags --> is search_order (search at what "order" level)
1245     search_full_world(s, partial, search_flags, &my_jni_object, &g7, radius);
1246     }
1247     }
1248    
1249     (*env)->ReleaseStringUTFChars(env, str, s);
1250     }
1251    
1252     JNIEXPORT jint JNICALL
1253 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitGraphics_CallbackDestinationValid(JNIEnv* env, jobject thiz)
1254 zoff99 2 {
1255 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1256 zoff99 40 dbg(0,"+#+:enter\n");
1257 zoff99 28 #endif
1258 zoff99 30 //DBG // dbg(0,"EEnter\n");
1259 zoff99 2 config_get_attr(config, attr_navit, &attr, NULL);
1260 zoff99 30 // //DBG // dbg(0,"destination_valid=%d\n",attr.u.navit->destination_valid);
1261 zoff99 27 jint i = 0;
1262 zoff99 2 if (attr.u.navit->route)
1263     {
1264     struct route *r;
1265 zoff99 27 r = attr.u.navit->route;
1266     i = r->route_status;
1267 zoff99 30 // //DBG // dbg(0,"route_status=%d\n",i);
1268 zoff99 2 }
1269     return i;
1270     }
1271    
1272     static void map_preview_label_line(struct point *p, int count, char *label, int font_size)
1273     {
1274 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1275 zoff99 40 dbg(0,"+#+:enter\n");
1276 zoff99 28 #endif
1277 zoff99 27 int i, x, y, tl, tlm, th, thm, tlsq, l;
1278 zoff99 2 float lsq;
1279 zoff99 27 double dx, dy;
1280 zoff99 2 struct point p_t;
1281     struct point pb[5];
1282    
1283     int len = g_utf8_strlen(label, -1);
1284     int xMin = 0;
1285     int yMin = 0;
1286 zoff99 27 int yMax = 13 * font_size / 256;
1287     int xMax = 9 * font_size * len / 256;
1288 zoff99 2
1289 zoff99 30 ////DBG // dbg(0,"xMax=%d\n", xMax);
1290     ////DBG // dbg(0,"yMax=%d\n", yMax);
1291 zoff99 2
1292     pb[0].x = xMin;
1293     pb[0].y = -yMin;
1294     pb[1].x = xMin;
1295     pb[1].y = -yMax;
1296     pb[2].x = xMax;
1297     pb[2].y = -yMax;
1298     pb[3].x = xMax;
1299     pb[3].y = -yMin;
1300    
1301 zoff99 27 tl = (pb[2].x - pb[0].x);
1302     th = (pb[0].y - pb[1].y);
1303 zoff99 2
1304     // calc "tl" text length
1305     // tl=strlen(label)*4;
1306     // calc "th" text height
1307     // th=8;
1308    
1309 zoff99 27 tlm = tl * 32;
1310     thm = th * 36;
1311     tlsq = (tlm * 0.7) * (tlm * 0.7);
1312 zoff99 2
1313 zoff99 27 for (i = 0; i < count - 1; i++)
1314 zoff99 2 {
1315 zoff99 27 dx = p[i + 1].x - p[i].x;
1316     dx *= 32;
1317     dy = p[i + 1].y - p[i].y;
1318     dy *= 32;
1319     lsq = dx * dx + dy * dy;
1320 zoff99 2
1321     if (lsq > tlsq)
1322     {
1323 zoff99 30 ////DBG // dbg(0,"-------- label=%s\n",label);
1324     ////DBG // dbg(0,"px i=%d py i=%d px i+1=%d py i+1=%d\n",p[i].x,p[i].y,p[i+1].x,p[i+1].y);
1325     ////DBG // dbg(0,"dx=%f dy=%f\n",dx,dy);
1326 zoff99 27 l = (int) sqrtf(lsq);
1327 zoff99 30 ////DBG // dbg(0,"l=%d lsq=%f\n",l,lsq);
1328 zoff99 27 x = p[i].x;
1329     y = p[i].y;
1330 zoff99 2 if (dx < 0)
1331     {
1332 zoff99 27 dx = -dx;
1333     dy = -dy;
1334     x = p[i + 1].x;
1335     y = p[i + 1].y;
1336 zoff99 2 }
1337 zoff99 27 x += (l - tlm) * dx / l / 64;
1338     y += (l - tlm) * dy / l / 64;
1339     x -= dy * thm / l / 64;
1340     y += dx * thm / l / 64;
1341     p_t.x = x;
1342     p_t.y = y;
1343 zoff99 2
1344 zoff99 30 ////DBG // dbg(0,"dx=%f dy=%f\n",dx,dy);
1345     ////DBG // dbg(0,"dx=%d dy=%d\n",(int)dx,(int)dy);
1346     ////DBG // dbg(0,"draw px=%d py=%d\n",p_t.x,p_t.y);
1347     ////DBG // dbg(0,"l=%d\n",l);
1348     ////DBG // dbg(0,"+++++++++++++\n");
1349 zoff99 2 // **OLD and wrong** android_DrawMapPreview_text(p_t.x, p_t.y, label, font_size, dx*0x10000/l, dy*0x10000/l);
1350 zoff99 27 android_DrawMapPreview_text(p_t.x, p_t.y, label, font_size, (int) dx, (int) dy);
1351 zoff99 2 }
1352     }
1353     }
1354    
1355 zoff99 50
1356    
1357 zoff99 2 JNIEXPORT void JNICALL
1358 zoff99 50 Java_com_zoffcc_applications_zanavi_NavitGraphics_DrawLowqualMap(JNIEnv* env, jobject thiz, jobject latlonzoom, int width, int height, int font_size, int scale, int sel_range)
1359     {
1360     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1361     dbg(0,"+#+:enter\n");
1362     #endif
1363     // config_get_attr(config, attr_navit, &attr, NULL);
1364    
1365     const char *s;
1366     int zoom;
1367     s = (*env)->GetStringUTFChars(env, latlonzoom, NULL);
1368     char parse_str[strlen(s) + 1];
1369     strcpy(parse_str, s);
1370     (*env)->ReleaseStringUTFChars(env, latlonzoom, s);
1371     ////DBG // dbg(0,"*****string=%s\n",s);
1372    
1373     // show map preview for (lat#lon#zoom)
1374     struct coord_geo g;
1375     char *p;
1376     char *stopstring;
1377    
1378     // lat
1379     p = strtok(parse_str, "#");
1380     g.lat = strtof(p, &stopstring);
1381     // lon
1382     p = strtok(NULL, "#");
1383     g.lng = strtof(p, &stopstring);
1384     // zoom
1385     p = strtok(NULL, "#");
1386     zoom = atoi(p);
1387    
1388     ////DBG // dbg(0,"lat=%f\n",g.lat);
1389     ////DBG // dbg(0,"lng=%f\n",g.lng);
1390     ////DBG // dbg(0,"zoom=%d\n",zoom);
1391     ////DBG // dbg(0,"w=%d\n",width);
1392     ////DBG // dbg(0,"h=%d\n",height);
1393    
1394     struct coord c;
1395     transform_from_geo(projection_mg, &g, &c);
1396    
1397     // struct pcoord pc;
1398     // pc.x=c.x;
1399     // pc.y=c.y;
1400     // pc.pro=projection_mg;
1401    
1402    
1403     // ----------------------- big draw loop -----------------------
1404     // ----------------------- big draw loop -----------------------
1405     // ----------------------- big draw loop -----------------------
1406     // ----------------------- big draw loop -----------------------
1407     struct item *item;
1408     struct map_rect *mr = NULL;
1409     struct mapset *ms;
1410     struct mapset_handle *msh;
1411     struct map* map = NULL;
1412     struct attr map_name_attr;
1413     struct attr attr;
1414    
1415     struct map_selection sel;
1416     const int selection_range = sel_range; // should be something with "width" and "height" i guess ??!!
1417    
1418     const int max = 100;
1419     int count;
1420     struct coord *ca = g_alloca(sizeof(struct coord) * max);
1421     struct point *pa = g_alloca(sizeof(struct point) * max);
1422    
1423     sel.next = NULL;
1424     sel.order = zoom;
1425     sel.range.min = type_none;
1426     sel.range.max = type_last;
1427     sel.u.c_rect.lu.x = c.x - selection_range;
1428     sel.u.c_rect.lu.y = c.y + selection_range;
1429     sel.u.c_rect.rl.x = c.x + selection_range;
1430     sel.u.c_rect.rl.y = c.y - selection_range;
1431    
1432     struct transformation *tr;
1433     tr = transform_dup(global_navit->trans);
1434     struct point p_center;
1435     p_center.x = width / 2;
1436     p_center.y = height / 2;
1437     transform_set_screen_center(tr, &p_center);
1438     transform_set_center(tr, &c);
1439     transform_set_scale(tr, scale);
1440     enum projection pro = transform_get_projection(global_navit->trans_cursor);
1441    
1442     // reset cancel flag
1443     global_cancel_preview_map_drawing = 0;
1444    
1445     ms = global_navit->mapsets->data;
1446     msh = mapset_open(ms);
1447     while (msh && (map = mapset_next(msh, 0)))
1448     {
1449     if (map_get_attr(map, attr_name, &map_name_attr, NULL))
1450     {
1451     if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0)
1452     {
1453     if (strncmp("_ms_sdcard_map:/sdcard/zanavi/maps/navitmap", map_name_attr.u.str, 38) == 0)
1454     {
1455     // its an sdcard map
1456     mr = map_rect_new(map, &sel);
1457     if (mr)
1458     {
1459     while ((item = map_rect_get_item(mr)))
1460     {
1461    
1462     if (global_cancel_preview_map_drawing == 1)
1463     {
1464     dbg(0, "global_cancel_preview_map_drawing = 1");
1465     break;
1466     }
1467    
1468     count = item_coord_get_within_selection(item, ca, max, &sel);
1469    
1470     if (!count)
1471     {
1472     continue;
1473     }
1474    
1475     struct attr attr_77;
1476     if (item_attr_get(item, attr_flags, &attr_77))
1477     {
1478     item->flags = attr_77.u.num;
1479     }
1480     else
1481     {
1482     item->flags = 0;
1483     }
1484    
1485     count = transform(tr, pro, ca, pa, count, 0, 0, NULL);
1486    
1487     if (item_is_street(*item))
1488     {
1489     android_DrawPreview_polyline(pa, count, 0, item_to_name(item->type));
1490     }
1491    
1492     }
1493     map_rect_destroy(mr);
1494     }
1495     }
1496     }
1497     }
1498     }
1499     mapset_close(msh);
1500    
1501     // ===============================================
1502    
1503     if (global_cancel_preview_map_drawing == 1)
1504     {
1505     dbg(0, "global_cancel_preview_map_drawing = 1");
1506     return;
1507     }
1508    
1509    
1510     // ===============================================
1511    
1512    
1513     msh = mapset_open(ms);
1514     while (msh && (map = mapset_next(msh, 0)))
1515     {
1516     if (map_get_attr(map, attr_name, &map_name_attr, NULL))
1517     {
1518     if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0)
1519     {
1520     if (strncmp("_ms_sdcard_map:/sdcard/zanavi/maps/navitmap", map_name_attr.u.str, 38) == 0)
1521     {
1522     // its an sdcard map
1523     mr = map_rect_new(map, &sel);
1524     if (mr)
1525     {
1526     while ((item = map_rect_get_item(mr)))
1527     {
1528    
1529     if (global_cancel_preview_map_drawing == 1)
1530     {
1531     dbg(0, "global_cancel_preview_map_drawing = 1");
1532     break;
1533     }
1534    
1535     count = item_coord_get_within_selection(item, ca, max, &sel);
1536    
1537     if (!count)
1538     {
1539     continue;
1540     }
1541    
1542     struct attr attr_77;
1543     if (item_attr_get(item, attr_flags, &attr_77))
1544     {
1545     item->flags = attr_77.u.num;
1546     }
1547     else
1548     {
1549     item->flags = 0;
1550     }
1551    
1552     count = transform(tr, pro, ca, pa, count, 0, 0, NULL);
1553    
1554     if (item_type_is_area(item->type))
1555     {
1556     android_DrawPreview_polyline(pa, count, 0, item_to_name(item->type));
1557     }
1558    
1559     }
1560     map_rect_destroy(mr);
1561     }
1562     }
1563     }
1564     }
1565     }
1566     mapset_close(msh);
1567    
1568    
1569    
1570    
1571    
1572    
1573     /*
1574     enum projection pro2 = transform_get_projection(global_navit->trans_cursor);
1575     struct point pnt;
1576     transform(tr, pro2, &c, &pnt, 1, 0, 0, NULL);
1577     transform_destroy(tr);
1578    
1579     */
1580     }
1581    
1582    
1583    
1584    
1585    
1586    
1587    
1588    
1589    
1590     JNIEXPORT void JNICALL
1591 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitMapPreviewActivity_DrawMapPreview(JNIEnv* env, jobject thiz, jobject latlonzoom, int width, int height, int font_size, int scale, int sel_range)
1592 zoff99 2 {
1593 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1594 zoff99 40 dbg(0,"+#+:enter\n");
1595 zoff99 28 #endif
1596 zoff99 2 // config_get_attr(config, attr_navit, &attr, NULL);
1597    
1598     const char *s;
1599     int zoom;
1600 zoff99 27 s = (*env)->GetStringUTFChars(env, latlonzoom, NULL);
1601 zoff99 2 char parse_str[strlen(s) + 1];
1602     strcpy(parse_str, s);
1603     (*env)->ReleaseStringUTFChars(env, latlonzoom, s);
1604 zoff99 30 ////DBG // dbg(0,"*****string=%s\n",s);
1605 zoff99 2
1606     // show map preview for (lat#lon#zoom)
1607     struct coord_geo g;
1608     char *p;
1609     char *stopstring;
1610    
1611     // lat
1612 zoff99 27 p = strtok(parse_str, "#");
1613 zoff99 2 g.lat = strtof(p, &stopstring);
1614     // lon
1615 zoff99 27 p = strtok(NULL, "#");
1616 zoff99 2 g.lng = strtof(p, &stopstring);
1617     // zoom
1618 zoff99 27 p = strtok(NULL, "#");
1619     zoom = atoi(p);
1620 zoff99 2
1621 zoff99 30 ////DBG // dbg(0,"lat=%f\n",g.lat);
1622     ////DBG // dbg(0,"lng=%f\n",g.lng);
1623     ////DBG // dbg(0,"zoom=%d\n",zoom);
1624     ////DBG // dbg(0,"w=%d\n",width);
1625     ////DBG // dbg(0,"h=%d\n",height);
1626 zoff99 2
1627     struct coord c;
1628     transform_from_geo(projection_mg, &g, &c);
1629    
1630     // struct pcoord pc;
1631     // pc.x=c.x;
1632     // pc.y=c.y;
1633     // pc.pro=projection_mg;
1634    
1635    
1636     // ----------------------- big draw loop -----------------------
1637     // ----------------------- big draw loop -----------------------
1638     // ----------------------- big draw loop -----------------------
1639     // ----------------------- big draw loop -----------------------
1640     struct item *item;
1641 zoff99 27 struct map_rect *mr = NULL;
1642 zoff99 2 struct mapset *ms;
1643     struct mapset_handle *msh;
1644     struct map* map = NULL;
1645     struct attr map_name_attr;
1646     struct attr attr;
1647    
1648     struct map_selection sel;
1649     const int selection_range = sel_range; // should be something with "width" and "height" i guess ??!!
1650    
1651 zoff99 27 const int max = 100;
1652 zoff99 2 int count;
1653 zoff99 27 struct coord *ca = g_alloca(sizeof(struct coord) * max);
1654     struct point *pa = g_alloca(sizeof(struct point) * max);
1655 zoff99 2
1656 zoff99 27 sel.next = NULL;
1657     sel.order = zoom;
1658     sel.range.min = type_none;
1659     sel.range.max = type_last;
1660     sel.u.c_rect.lu.x = c.x - selection_range;
1661     sel.u.c_rect.lu.y = c.y + selection_range;
1662     sel.u.c_rect.rl.x = c.x + selection_range;
1663     sel.u.c_rect.rl.y = c.y - selection_range;
1664 zoff99 2
1665     struct transformation *tr;
1666 zoff99 27 tr = transform_dup(global_navit->trans);
1667 zoff99 2 struct point p_center;
1668 zoff99 27 p_center.x = width / 2;
1669     p_center.y = height / 2;
1670 zoff99 2 transform_set_screen_center(tr, &p_center);
1671     transform_set_center(tr, &c);
1672     transform_set_scale(tr, scale);
1673 zoff99 27 enum projection pro = transform_get_projection(global_navit->trans_cursor);
1674 zoff99 2
1675 zoff99 27 ms = global_navit->mapsets->data;
1676     msh = mapset_open(ms);
1677     while (msh && (map = mapset_next(msh, 0)))
1678 zoff99 2 {
1679 zoff99 27 if (map_get_attr(map, attr_name, &map_name_attr, NULL))
1680 zoff99 2 {
1681     if (strncmp("_ms_sdcard_map:", map_name_attr.u.str, 15) == 0)
1682     {
1683     if (strncmp("_ms_sdcard_map:/sdcard/zanavi/maps/borders.bin", map_name_attr.u.str, 41) == 0)
1684     {
1685     // country borders
1686 zoff99 30 // //DBG // dbg(0,"map name=%s",map_name_attr.u.str);
1687 zoff99 27 mr = map_rect_new(map, NULL);
1688 zoff99 2 if (mr)
1689     {
1690 zoff99 27 while ((item = map_rect_get_item(mr)))
1691 zoff99 2 {
1692    
1693     // count=item_coord_get_within_selection(item, ca, item->type < type_line ? 1: max, &sel);
1694 zoff99 27 count = item_coord_get_within_selection(item, ca, max, &sel);
1695     if (!count)
1696 zoff99 2 {
1697     continue;
1698     }
1699 zoff99 27 count = transform(tr, pro, ca, pa, count, 0, 0, NULL);
1700 zoff99 2
1701 zoff99 30 // //DBG // dbg(0,"uu %s\n",item_to_name(item->type));
1702 zoff99 2
1703     if (item->type == type_border_country)
1704     {
1705 zoff99 30 // //DBG // dbg(0,"BB** %s\n",item_to_name(item->type));
1706 zoff99 2 android_DrawMapPreview_polyline(pa, count, 2);
1707     }
1708     }
1709     map_rect_destroy(mr);
1710     }
1711     }
1712     else if (strncmp("_ms_sdcard_map:/sdcard/zanavi/maps/navitmap", map_name_attr.u.str, 38) == 0)
1713     {
1714     // its an sdcard map
1715 zoff99 30 // //DBG // dbg(0,"map name=%s",map_name_attr.u.str);
1716 zoff99 27 mr = map_rect_new(map, &sel);
1717 zoff99 2 if (mr)
1718     {
1719     //char *streetname_last=NULL;
1720    
1721 zoff99 27 while ((item = map_rect_get_item(mr)))
1722 zoff99 2 {
1723 zoff99 27 int label_count = 0;
1724 zoff99 2 char *labels[2];
1725    
1726     // count=item_coord_get_within_selection(item, ca, item->type < type_line ? 1: max, &sel);
1727 zoff99 27 count = item_coord_get_within_selection(item, ca, max, &sel);
1728 zoff99 2
1729     // count=item_coord_get_within_selection(item, ca, max, &sel);
1730     // count=item_coord_get(item, ca, item->type < type_line ? 1: max);
1731 zoff99 27 if (!count)
1732 zoff99 2 {
1733     continue;
1734     }
1735 zoff99 30 ////DBG // dbg(0,"count 1=%d\n", count);
1736 zoff99 2
1737     if (count == max)
1738     {
1739 zoff99 30 ////DBG // dbg(0,"count overflow!!\n");
1740 zoff99 2 }
1741    
1742     struct attr attr_77;
1743     if (item_attr_get(item, attr_flags, &attr_77))
1744     {
1745 zoff99 30 ////DBG // dbg(0,"uuuuuuuuuuuuu %s uuuuu %d\n",item_to_name(item->type), attr_77.u.num);
1746 zoff99 27 item->flags = attr_77.u.num;
1747 zoff99 2 }
1748     else
1749     {
1750 zoff99 27 item->flags = 0;
1751 zoff99 2 }
1752    
1753     //if (item_is_street(*item))
1754     //{
1755     // int i3;
1756     // for (i3 = 0 ; i3 < count ; i3++)
1757     // {
1758     // if (i3)
1759     // {
1760 zoff99 30 // //DBG // dbg(0,"1 x1=%d\n",ca[i3-1].x);
1761     // //DBG // dbg(0,"1 y1=%d\n",ca[i3-1].y);
1762     // //DBG // dbg(0,"1 x2=%d\n",ca[i3].x);
1763     // //DBG // dbg(0,"1 y2=%d\n",ca[i3].y);
1764 zoff99 2 // }
1765     // }
1766     //}
1767    
1768 zoff99 27 count = transform(tr, pro, ca, pa, count, 0, 0, NULL);
1769 zoff99 2
1770 zoff99 30 ////DBG // dbg(0,"count 2=%d\n", count);
1771 zoff99 2
1772     // --- LABEL ---
1773 zoff99 27 labels[1] = NULL;
1774     label_count = 0;
1775 zoff99 2 if (item_attr_get(item, attr_label, &attr))
1776     {
1777 zoff99 27 labels[0] = attr.u.str;
1778 zoff99 30 ////DBG // dbg(0,"labels[0]=%s\n",attr.u.str);
1779 zoff99 2 if (!label_count)
1780     {
1781 zoff99 27 label_count = 2;
1782 zoff99 2 }
1783     }
1784     else
1785     {
1786 zoff99 27 labels[0] = NULL;
1787 zoff99 2 }
1788     // --- LABEL ---
1789    
1790     if (item_is_street(*item))
1791     {
1792     //int i3;
1793     //for (i3 = 0 ; i3 < count ; i3++)
1794     //{
1795     // if (i3)
1796     // {
1797 zoff99 30 // //DBG // dbg(0,"2 x1=%d\n",pa[i3-1].x);
1798     // //DBG // dbg(0,"2 y1=%d\n",pa[i3-1].y);
1799     // //DBG // dbg(0,"2 x2=%d\n",pa[i3].x);
1800     // //DBG // dbg(0,"2 y2=%d\n",pa[i3].y);
1801 zoff99 2 // }
1802     //}
1803     android_DrawMapPreview_polyline(pa, count, 0);
1804     if (labels[0] != NULL)
1805     {
1806     map_preview_label_line(pa, count, labels[0], font_size);
1807     }
1808     }
1809     else if (item_is_district(*item))
1810     {
1811 zoff99 27 if (zoom > 6)
1812     {
1813 zoff99 30 // //DBG // dbg(0,"xx** %s - %s\n",item_to_name(item->type),labels[0]);
1814 zoff99 27 if (count >= 1)
1815 zoff99 2 {
1816 zoff99 27 android_DrawMapPreview_text(pa[0].x, pa[0].y, labels[0], font_size * 2, 0x10000, 0);
1817 zoff99 2 }
1818 zoff99 27 }
1819 zoff99 2 }
1820     else if (item_is_town(*item))
1821     {
1822 zoff99 30 // //DBG // dbg(0,"yy** %s - %s\n",item_to_name(item->type),labels[0]);
1823 zoff99 27 if (count >= 1)
1824     {
1825     android_DrawMapPreview_text(pa[0].x, pa[0].y, labels[0], font_size * 3, 0x10000, 0);
1826     }
1827 zoff99 2 }
1828    
1829     //if (item_is_street(*item))
1830     //{
1831     // if (item_attr_get(item, attr_label, &attr))
1832     // {
1833 zoff99 30 // ////DBG // dbg(0,"street1=%s\n",map_convert_string(item->map, attr.u.str));
1834 zoff99 2 // if ( (streetname_last==NULL) || (strcmp(streetname_last,attr.u.str) != 0) )
1835     // {
1836 zoff99 30 // ////DBG // dbg(0,"street2=%s\n",map_convert_string(item->map, attr.u.str));
1837 zoff99 2 // }
1838     // }
1839     //}
1840     }
1841     //g_free(streetname_last);
1842     map_rect_destroy(mr);
1843     }
1844     }
1845     }
1846     }
1847     }
1848     mapset_close(msh);
1849    
1850 zoff99 27 enum projection pro2 = transform_get_projection(global_navit->trans_cursor);
1851 zoff99 2 struct point pnt;
1852     transform(tr, pro2, &c, &pnt, 1, 0, 0, NULL);
1853     transform_destroy(tr);
1854     // ----------------------- big draw loop -----------------------
1855     // ----------------------- big draw loop -----------------------
1856     // ----------------------- big draw loop -----------------------
1857     // ----------------------- big draw loop -----------------------
1858    
1859     android_DrawMapPreview_target(pnt.x, pnt.y);
1860     }
1861    
1862 zoff99 27 void android_DrawMapPreview_target(int x, int y)
1863 zoff99 2 {
1864 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1865 zoff99 40 dbg(0,"+#+:enter\n");
1866 zoff99 28 #endif
1867 zoff99 30
1868     JNIEnv *jnienv2;
1869     jnienv2 = jni_getenv();
1870    
1871 zoff99 27 if (NavitMapPreviewActivityClass == NULL)
1872 zoff99 2 {
1873     if (!android_find_class_global("com/zoffcc/applications/zanavi/NavitMapPreviewActivity", &NavitMapPreviewActivityClass))
1874     {
1875 zoff99 27 NavitMapPreviewActivityClass = NULL;
1876 zoff99 2 return;
1877     }
1878     }
1879     if (DrawMapPreview_target == NULL)
1880     {
1881 zoff99 27 android_find_static_method(NavitMapPreviewActivityClass, "DrawMapPreview_target", "(II)V", &DrawMapPreview_target);
1882 zoff99 2 }
1883     if (DrawMapPreview_target == NULL)
1884     {
1885 zoff99 30 //DBG // dbg(0, "no method found\n");
1886 zoff99 2 return; /* exception thrown */
1887     }
1888 zoff99 30 (*jnienv2)->CallStaticVoidMethod(jnienv2, NavitMapPreviewActivityClass, DrawMapPreview_target, x, y);
1889 zoff99 2 }
1890    
1891 zoff99 27 void android_DrawMapPreview_text(int x, int y, char *text, int size, int dx, int dy)
1892 zoff99 2 {
1893 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1894 zoff99 40 dbg(0,"+#+:enter\n");
1895 zoff99 28 #endif
1896 zoff99 2
1897 zoff99 30 JNIEnv *jnienv2;
1898     jnienv2 = jni_getenv();
1899    
1900 zoff99 27 if (NavitMapPreviewActivityClass == NULL)
1901 zoff99 2 {
1902     if (!android_find_class_global("com/zoffcc/applications/zanavi/NavitMapPreviewActivity", &NavitMapPreviewActivityClass))
1903     {
1904 zoff99 27 NavitMapPreviewActivityClass = NULL;
1905 zoff99 2 return;
1906     }
1907     }
1908 zoff99 27 if (DrawMapPreview_text == NULL)
1909 zoff99 2 {
1910 zoff99 27 android_find_static_method(NavitMapPreviewActivityClass, "DrawMapPreview_text", "(IILjava/lang/String;III)V", &DrawMapPreview_text);
1911 zoff99 2 }
1912     if (DrawMapPreview_text == NULL)
1913     {
1914 zoff99 30 //DBG // dbg(0, "no method found\n");
1915 zoff99 2 return; /* exception thrown */
1916     }
1917    
1918 zoff99 30 ////DBG // dbg(0,"** dx=%d,dy=%d\n",dx,dy);
1919 zoff99 2
1920 zoff99 30 jstring string1 = (*jnienv2)->NewStringUTF(jnienv2, text);
1921     (*jnienv2)->CallStaticVoidMethod(jnienv2, NavitMapPreviewActivityClass, DrawMapPreview_text, x, y, string1, size, dx, dy);
1922     (*jnienv2)->DeleteLocalRef(jnienv2, string1);
1923 zoff99 2 }
1924    
1925 zoff99 27 void android_DrawMapPreview_polyline(struct point *p, int count, int type)
1926 zoff99 2 {
1927 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1928 zoff99 40 dbg(0,"+#+:enter\n");
1929 zoff99 28 #endif
1930 zoff99 2 // type:
1931     // 0 -> normal street
1932     // 2 -> country border
1933    
1934 zoff99 30 JNIEnv *jnienv2;
1935     jnienv2 = jni_getenv();
1936    
1937 zoff99 27 if (NavitMapPreviewActivityClass == NULL)
1938 zoff99 2 {
1939     if (!android_find_class_global("com/zoffcc/applications/zanavi/NavitMapPreviewActivity", &NavitMapPreviewActivityClass))
1940     {
1941 zoff99 27 NavitMapPreviewActivityClass = NULL;
1942 zoff99 2 return;
1943     }
1944     }
1945 zoff99 27 if (DrawMapPreview_polyline == NULL)
1946 zoff99 2 {
1947 zoff99 27 android_find_static_method(NavitMapPreviewActivityClass, "DrawMapPreview_polyline", "(I[I)V", &DrawMapPreview_polyline);
1948 zoff99 2 }
1949     if (DrawMapPreview_polyline == NULL)
1950     {
1951 zoff99 30 //DBG // dbg(0, "no method found\n");
1952 zoff99 2 return; /* exception thrown */
1953     }
1954    
1955 zoff99 27 jint pc[count * 2];
1956 zoff99 2 int i;
1957     jintArray points;
1958     if (count <= 0)
1959     {
1960     return;
1961     }
1962 zoff99 30 points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1963 zoff99 27 for (i = 0; i < count; i++)
1964 zoff99 2 {
1965 zoff99 27 pc[i * 2] = p[i].x;
1966     pc[i * 2 + 1] = p[i].y;
1967 zoff99 2 }
1968 zoff99 30 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1969     (*jnienv2)->CallStaticVoidMethod(jnienv2, NavitMapPreviewActivityClass, DrawMapPreview_polyline, type, points);
1970     (*jnienv2)->DeleteLocalRef(jnienv2, points);
1971 zoff99 2 }
1972    
1973 zoff99 41
1974 zoff99 50 void android_DrawPreview_polyline(struct point *p, int count, int type, const char* item_type)
1975     {
1976     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
1977     dbg(0,"+#+:enter\n");
1978     #endif
1979     // type:
1980     // 0 -> normal street
1981     // 2 -> country border
1982    
1983     JNIEnv *jnienv2;
1984     jnienv2 = jni_getenv();
1985    
1986    
1987     if (NavitGraphicsClass2 == NULL)
1988     {
1989     if (!android_find_class_global("com/zoffcc/applications/zanavi/NavitGraphics", &NavitGraphicsClass2))
1990     {
1991     NavitGraphicsClass2 = NULL;
1992     return;
1993     }
1994     }
1995    
1996    
1997     if (DrawPreview_polyline == NULL)
1998     {
1999     android_find_static_method(NavitGraphicsClass2, "DrawPreview_polyline", "(I[ILjava/lang/String;)V", &DrawPreview_polyline);
2000     }
2001    
2002     if (DrawPreview_polyline == NULL)
2003     {
2004     //DBG // dbg(0, "no method found\n");
2005     return; /* exception thrown */
2006     }
2007    
2008     jint pc[count * 2];
2009     int i;
2010     jintArray points;
2011     if (count <= 0)
2012     {
2013     return;
2014     }
2015    
2016     if (global_cancel_preview_map_drawing == 1)
2017     {
2018     return;
2019     }
2020    
2021    
2022     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
2023    
2024     for (i = 0; i < count; i++)
2025     {
2026     pc[i * 2] = p[i].x;
2027     pc[i * 2 + 1] = p[i].y;
2028     }
2029    
2030     jstring string1;
2031     if (item_type)
2032     {
2033     string1 = (*jnienv2)->NewStringUTF(jnienv2, item_type);
2034     }
2035     else
2036     {
2037     string1 = (*jnienv2)->NewStringUTF(jnienv2, "xx__unknown__xx");
2038     }
2039    
2040     (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
2041     (*jnienv2)->CallStaticVoidMethod(jnienv2, NavitGraphicsClass2, DrawPreview_polyline, type, points, string1);
2042     (*jnienv2)->DeleteLocalRef(jnienv2, points);
2043     (*jnienv2)->DeleteLocalRef(jnienv2, string1);
2044     }
2045    
2046    
2047 zoff99 41 JNIEXPORT jobjectArray JNICALL
2048     Java_com_zoffcc_applications_zanavi_NavitGraphics_GetRoadBookItems(JNIEnv *env, jobject thiz, int result_id)
2049     {
2050     jobjectArray ret;
2051     int i;
2052     jclass *string_class = (*env)->FindClass(env, "java/lang/String");
2053    
2054     // get roadbook
2055     GList *result = navit_route_export_to_java_string(global_navit, result_id);
2056    
2057     if (result == NULL)
2058     {
2059     return NULL;
2060     }
2061    
2062    
2063 zoff99 50 jstring string77 = (*env)->NewStringUTF(env, "");
2064     ret = (jobjectArray)(*env)->NewObjectArray(env, g_list_length(result), string_class, string77);
2065     (*env)->DeleteLocalRef(env, string77);
2066    
2067    
2068     jstring string88 = (*env)->NewStringUTF(env, "");
2069    
2070 zoff99 41 GList *result2 = result;
2071     i = 0;
2072     while (result2)
2073     {
2074     char *str = result2->data;
2075    
2076     if (str != NULL)
2077     {
2078 zoff99 50 jstring string99 = (*env)->NewStringUTF(env, str);
2079     (*env)->SetObjectArrayElement(env, ret, i, string99);
2080     (*env)->DeleteLocalRef(env, string99);
2081 zoff99 41 g_free(str);
2082     }
2083     else
2084     {
2085 zoff99 50 (*env)->SetObjectArrayElement(env, ret, i, string88);
2086 zoff99 41 }
2087     i++;
2088    
2089     result2 = g_list_next(result2);
2090     }
2091    
2092     g_list_free(result);
2093    
2094 zoff99 50 (*env)->DeleteLocalRef(env, string88);
2095    
2096 zoff99 41 return(ret);
2097     }
2098    
2099    
2100    
2101    
2102    
2103 zoff99 2 JNIEXPORT jstring JNICALL
2104 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitGraphics_CallbackGeoCalc(JNIEnv* env, jobject thiz, int i, float a, float b)
2105 zoff99 2 {
2106 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
2107 zoff99 40 dbg(0,"+#+:enter\n");
2108 zoff99 28 #endif
2109 zoff99 27 // dbg(0,"EEnter i=%d\n", i);
2110    
2111 zoff99 40
2112 zoff99 30 int thread_id = gettid();
2113     // dbg(0, "THREAD ID=%d\n", thread_id);
2114    
2115 zoff99 2 // const char *result;
2116 zoff99 41 gchar *result = NULL;
2117 zoff99 2
2118 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
2119    
2120 zoff99 2 if (i == 1)
2121     {
2122     // pixel-on-screen to geo
2123     struct coord_geo g22;
2124     struct coord c22;
2125     struct point p;
2126 zoff99 27 p.x = a;
2127     p.y = b;
2128 zoff99 2 transform_reverse(global_navit->trans, &p, &c22);
2129 zoff99 30 ////DBG // dbg(0,"%f, %f\n",a, b);
2130     ////DBG // dbg(0,"%d, %d\n",p.x, p.y);
2131 zoff99 2 transform_to_geo(projection_mg, &c22, &g22);
2132 zoff99 30 ////DBG // dbg(0,"%d, %d, %f, %f\n",c22.x, c22.y, g22.lat, g22.lng);
2133 zoff99 27 result = g_strdup_printf("%f:%f", g22.lat, g22.lng);
2134 zoff99 2 }
2135     else if (i == 2)
2136     {
2137     // geo to pixel-on-screen
2138     struct coord c99;
2139     struct coord_geo g99;
2140 zoff99 27 g99.lat = a;
2141     g99.lng = b;
2142 zoff99 30 ////DBG // dbg(0,"zzzzz %f, %f\n",a, b);
2143     ////DBG // dbg(0,"yyyyy %f, %f\n",g99.lat, g99.lng);
2144 zoff99 2 transform_from_geo(projection_mg, &g99, &c99);
2145 zoff99 30 ////DBG // dbg(0,"%d %d %f %f\n",c99.x, c99.y, g99.lat, g99.lng);
2146 zoff99 2
2147 zoff99 27 enum projection pro = transform_get_projection(global_navit->trans_cursor);
2148 zoff99 2 struct point pnt;
2149     transform(global_navit->trans, pro, &c99, &pnt, 1, 0, 0, NULL);
2150 zoff99 30 ////DBG // dbg(0,"x=%d\n",pnt.x);
2151     ////DBG // dbg(0,"y=%d\n",pnt.y);
2152 zoff99 2
2153 zoff99 27 result = g_strdup_printf("%d:%d", pnt.x, pnt.y);
2154 zoff99 2 }
2155     else if (i == 3)
2156     {
2157     // show lat,lng position on screen center
2158     struct coord c99;
2159     struct pcoord pc99;
2160     struct coord_geo g99;
2161 zoff99 27 g99.lat = a;
2162     g99.lng = b;
2163 zoff99 30 ////DBG // dbg(0,"zzzzz %f, %f\n",a, b);
2164     ////DBG // dbg(0,"yyyyy %f, %f\n",g99.lat, g99.lng);
2165 zoff99 2 transform_from_geo(projection_mg, &g99, &c99);
2166 zoff99 30 ////DBG // dbg(0,"%d %d %f %f\n",c99.x, c99.y, g99.lat, g99.lng);
2167 zoff99 2
2168     //enum projection pro=transform_get_projection(global_navit->trans_cursor);
2169     //struct point pnt;
2170     //transform(global_navit->trans, pro, &c99, &pnt, 1, 0, 0, NULL);
2171 zoff99 30 ////DBG // dbg(0,"x=%d\n",pnt.x);
2172     ////DBG // dbg(0,"y=%d\n",pnt.y);
2173 zoff99 27 pc99.x = c99.x;
2174     pc99.y = c99.y;
2175     pc99.pro = projection_mg;
2176 zoff99 2
2177     navit_set_center(global_navit, &pc99, 0);
2178    
2179 zoff99 40 result = g_strdup("1:1");
2180 zoff99 2 }
2181 zoff99 27 else if (i == 4)
2182     {
2183     // return current target (the end point, not waypoints)
2184     struct coord_geo g22;
2185     struct pcoord c22;
2186     struct coord c99;
2187 zoff99 2
2188 zoff99 27 c22 = global_navit->destination;
2189     c99.x = c22.x;
2190     c99.y = c22.y;
2191    
2192     transform_to_geo(projection_mg, &c99, &g22);
2193     result = g_strdup_printf("%f:%f", g22.lat, g22.lng);
2194     }
2195 zoff99 28 else if (i == 5)
2196     {
2197     // input: x,y pixel on screen
2198     // output: streetname nearest that position
2199     struct coord c22;
2200     struct point p;
2201     struct pcoord c24;
2202     p.x = a;
2203     p.y = b;
2204     transform_reverse(global_navit->trans, &p, &c22);
2205     c24.x = c22.x;
2206     c24.y = c22.y;
2207     c24.pro = transform_get_projection(global_navit->trans);
2208     result = navit_find_nearest_street(global_navit->mapsets->data, &c24);
2209     }
2210     else if (i == 6)
2211     {
2212     // input: lat, lon
2213     // output: streetname nearest that position
2214     struct coord c22;
2215     struct point p;
2216     struct pcoord c24;
2217     struct coord_geo g99;
2218     g99.lat = a;
2219     g99.lng = b;
2220     transform_from_geo(projection_mg, &g99, &c22);
2221     c24.x = c22.x;
2222     c24.y = c22.y;
2223     c24.pro = transform_get_projection(global_navit->trans);
2224     result = navit_find_nearest_street(global_navit->mapsets->data, &c24);
2225     }
2226     else if (i == 7)
2227     {
2228     // input: x,y pixel on screen
2229     // output: 0xFFFF 0xFFFF\n... -> string that can be used for traffic distortion file
2230     struct coord c22;
2231     struct point p;
2232     struct pcoord c24;
2233     p.x = a;
2234     p.y = b;
2235     transform_reverse(global_navit->trans, &p, &c22);
2236     c24.x = c22.x;
2237     c24.y = c22.y;
2238     c24.pro = transform_get_projection(global_navit->trans);
2239     result = navit_find_nearest_street_coords(global_navit->mapsets->data, &c24);
2240     }
2241 zoff99 29 else if (i == 8)
2242     {
2243     // input: x,y pixel on screen
2244     // output: nearest street or housenumber
2245     struct coord c22;
2246     struct point p;
2247     struct pcoord c24;
2248     p.x = a;
2249     p.y = b;
2250     transform_reverse(global_navit->trans, &p, &c22);
2251     c24.x = c22.x;
2252     c24.y = c22.y;
2253     c24.pro = transform_get_projection(global_navit->trans);
2254     result = navit_find_nearest_street_hn(global_navit->mapsets->data, &c24);
2255     }
2256     else if (i == 9)
2257     {
2258     // input: x,y pixel on screen
2259     // output: item dump of nearest item
2260     struct coord c22;
2261     struct point p;
2262     struct pcoord c24;
2263     p.x = a;
2264     p.y = b;
2265     transform_reverse(global_navit->trans, &p, &c22);
2266     c24.x = c22.x;
2267     c24.y = c22.y;
2268     c24.pro = transform_get_projection(global_navit->trans);
2269     result = navit_find_nearest_item_dump(global_navit->mapsets->data, &c24, 0);
2270     }
2271     else if (i == 10)
2272     {
2273     // input: x,y pixel on screen
2274     // output: item dump of nearest item (pretty output to show to user)
2275     struct coord c22;
2276     struct point p;
2277     struct pcoord c24;
2278     p.x = a;
2279     p.y = b;
2280     transform_reverse(global_navit->trans, &p, &c22);
2281     c24.x = c22.x;
2282     c24.y = c22.y;
2283     c24.pro = transform_get_projection(global_navit->trans);
2284     result = navit_find_nearest_item_dump(global_navit->mapsets->data, &c24, 1);
2285     }
2286 zoff99 31 else if (i == 11)
2287     {
2288     // coord to pixel-on-screen
2289     struct coord c99;
2290     c99.x = a;
2291     c99.y = b;
2292     struct point pnt;
2293     transform(global_navit->trans, projection_mg, &c99, &pnt, 1, 0, 0, NULL);
2294     result = g_strdup_printf("%d:%d", pnt.x, pnt.y);
2295     }
2296 zoff99 41 // else if (i == 13)
2297     // {
2298     // // get roadbook
2299     // result = navit_route_export_to_java_string(global_navit, NULL, (int)a);
2300     // }
2301 zoff99 40 else if (i == 12)
2302     {
2303     // calculate next position in interpolation on route
2304     // return string: lat:lon:direction
2305     // example : 48.62:16.775:45.5
2306 zoff99 27
2307 zoff99 40 struct route *route2 = NULL;
2308     struct map *route_map2 = NULL;
2309     struct map_rect *mr2 = NULL;
2310     struct item *item2 = NULL;
2311     struct coord pos;
2312     struct coord *pos2;
2313     struct coord c;
2314     struct coord c2;
2315     struct coord ci;
2316     struct coord_geo g99;
2317     struct attr attr;
2318     // struct street_data *sd;
2319     int seg_speed;
2320     int seg_speed_old;
2321     int len;
2322     int slen;
2323     int dx;
2324     int dy;
2325     float dir;
2326     int interval = 1000; // milliseconds
2327     int speed = 50; // km/h
2328    
2329    
2330     if (global_demo_vehicle == 0)
2331     {
2332     route2 = navit_get_route(global_navit);
2333    
2334     if (route2)
2335     {
2336     route_map2 = route_get_map(route2);
2337     }
2338    
2339     if (route_map2)
2340     {
2341     mr2 = map_rect_new(route_map2, NULL);
2342     }
2343    
2344     if (mr2)
2345     {
2346     item2 = map_rect_get_item(mr2);
2347     }
2348    
2349     if (item2 && item2->type == type_route_start)
2350     {
2351     item2 = map_rect_get_item(mr2);
2352     }
2353    
2354     if (item2 && item2->type == type_route_start_reverse)
2355     {
2356     item2 = map_rect_get_item(mr2);
2357     }
2358    
2359     if (item2 && item_coord_get(item2, &pos, 1))
2360     {
2361     pos2 = tracking_get_pos(global_navit->tracking);
2362     pos.x = pos2->x;
2363     pos.y = pos2->y;
2364    
2365     dbg(0,"extrapl:002 posx=%d posy=%d itemtype=%s\n", pos.x, pos.y, item_to_name(item2->type));
2366    
2367     seg_speed = speed;
2368     // item_dump_attr_stdout(item2, route_map2);
2369     if (item_attr_get(item2, attr_maxspeed, &attr))
2370     {
2371     dbg(0, "extrapl:002.2 max speed=%d\n", attr.u.num);
2372     seg_speed = attr.u.num;
2373     }
2374     seg_speed_old = seg_speed;
2375    
2376     len = (seg_speed * interval / 1000) / 3.6; // distance in meters that we drive in 1 second with "seg_speed" km/h !!
2377    
2378     while (item2)
2379     {
2380     if (!item_coord_get(item2, &c, 1))
2381     {
2382     item2 = map_rect_get_item(mr2);
2383    
2384     if (item2)
2385     {
2386     dbg(0,"extrapl:004 item type=%s\n", item_to_name(item2->type));
2387    
2388     // item_dump_attr_stdout(item2, route_map2);
2389     if (item_attr_get(item2, attr_maxspeed, &attr))
2390     {
2391     dbg(0, "extrapl:004.2 max speed=%d\n", attr.u.num);
2392     seg_speed = attr.u.num;
2393     }
2394     }
2395     continue;
2396     }
2397    
2398     slen = transform_distance(projection_mg, &pos, &c); // distance between position and current route coord
2399     dbg(0,"extrapl:004.1 slen=%d len=%d\n", slen, len);
2400    
2401     if (slen < len) // need to move along the route some more ...
2402     {
2403     len = len - slen;
2404     dbg(0,"extrapl:005 cx=%d cy=%d len=%d\n", c.x, c.y, len);
2405     // now compensate "len" for maybe other speed on next item
2406     if (seg_speed != seg_speed_old)
2407     {
2408     if ((len > 0) && (seg_speed_old > 0)&&(seg_speed > 0))
2409     {
2410     len = (int)((float)len / (float)seg_speed_old * (float)seg_speed);
2411     dbg(0,"extrapl:005.1 len comp.=%d speed=%d speed old=%d\n", len, seg_speed, seg_speed_old);
2412     }
2413     seg_speed_old = seg_speed;
2414     }
2415    
2416     pos = c;
2417     }
2418     else
2419     {
2420     if (item_coord_get(item2, &c2, 1) || map_rect_get_item(mr2))
2421     {
2422     dbg(0,"extrapl:006 c2x=%d c2y=%d\n", c2.x, c2.y);
2423     dbg(0,"extrapl:006 cx=%d cy=%d\n", c.x, c.y);
2424    
2425     dx = c.x - pos.x;
2426     dy = c.y - pos.y;
2427     ci.x = pos.x + dx * len / slen;
2428     ci.y = pos.y + dy * len / slen;
2429    
2430     dbg(0,"extrapl:006 cix=%d ciy=%d\n", ci.x, ci.y);
2431    
2432     dir = (float)transform_get_angle_delta(&pos, &c, 0);
2433     }
2434     else
2435     {
2436     ci.x = pos.x;
2437     ci.y = pos.y;
2438     dir = 0.0f;
2439     dbg(0, "extrapl:destination reached\n");
2440     }
2441    
2442     transform_to_geo(projection_mg, &ci, &g99);
2443     dbg(0,"extrapl:099=%f:%f:%f\n", g99.lat, g99.lng, dir);
2444     result = g_strdup_printf("%f:%f:%f", g99.lat, g99.lng, dir);
2445    
2446     break;
2447     }
2448     }
2449     }
2450     else
2451     {
2452     result = g_strdup("*ERROR*");
2453     }
2454    
2455     if (mr2)
2456     {
2457     map_rect_destroy(mr2);
2458     }
2459     }
2460     else
2461     {
2462     result = g_strdup("*ERROR*");
2463     }
2464     }
2465 zoff99 41 else if (i == 14)
2466     {
2467     // return current position
2468     // dbg(0, "PPPOS:2:%f %f", ggggg_lat, ggggg_lon);
2469     result = g_strdup_printf("%f:%f", (float)ggggg_lat, (float)ggggg_lon);
2470     }
2471     else if (i == 15)
2472     {
2473     // show lat,lng position on screen center, without map redraw!
2474     struct coord c99;
2475     struct pcoord pc99;
2476     struct coord_geo g99;
2477     g99.lat = a;
2478     g99.lng = b;
2479     ////DBG // dbg(0,"zzzzz %f, %f\n",a, b);
2480     ////DBG // dbg(0,"yyyyy %f, %f\n",g99.lat, g99.lng);
2481     transform_from_geo(projection_mg, &g99, &c99);
2482     ////DBG // dbg(0,"%d %d %f %f\n",c99.x, c99.y, g99.lat, g99.lng);
2483 zoff99 40
2484 zoff99 41 //enum projection pro=transform_get_projection(global_navit->trans_cursor);
2485     //struct point pnt;
2486     //transform(global_navit->trans, pro, &c99, &pnt, 1, 0, 0, NULL);
2487     ////DBG // dbg(0,"x=%d\n",pnt.x);
2488     ////DBG // dbg(0,"y=%d\n",pnt.y);
2489     pc99.x = c99.x;
2490     pc99.y = c99.y;
2491     pc99.pro = projection_mg;
2492    
2493     navit_set_center_no_draw(global_navit, &pc99, 0);
2494    
2495     result = g_strdup("1:1");
2496     }
2497    
2498    
2499    
2500 zoff99 40 #else
2501     result = g_strdup("*ERROR*");
2502     #endif
2503    
2504 zoff99 30 // // dbg(0, "result=%s\n", result);
2505 zoff99 27 jstring js = (*env)->NewStringUTF(env, result);
2506 zoff99 2
2507 zoff99 41 if (result)
2508     {
2509     g_free(result);
2510     }
2511    
2512 zoff99 40 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
2513     dbg(0,"+#+:leave\n");
2514     #endif
2515    
2516 zoff99 2 return js;
2517     }
2518    
2519     JNIEXPORT jstring JNICALL
2520 zoff99 27 Java_com_zoffcc_applications_zanavi_NavitGraphics_CallbackLocalizedString(JNIEnv* env, jobject thiz, jobject str)
2521 zoff99 2 {
2522 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
2523 zoff99 40 dbg(0,"+#+:enter\n");
2524 zoff99 28 #endif
2525 zoff99 30 // // dbg(0,"EEnter\n");
2526 zoff99 27
2527 zoff99 30 int thread_id = gettid();
2528     // dbg(0, "THREAD ID=%d\n", thread_id);
2529    
2530 zoff99 2 const char *s;
2531     const char *localized_str;
2532    
2533 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
2534 zoff99 30 ////DBG // dbg(0,"*****string=%s\n",s);
2535 zoff99 2
2536 zoff99 27 localized_str = gettext(s);
2537 zoff99 30 ////DBG // dbg(0,"localized string=%s",localized_str);
2538 zoff99 2
2539     // jstring dataStringValue = (jstring) localized_str;
2540 zoff99 27 jstring js = (*env)->NewStringUTF(env, localized_str);
2541 zoff99 2
2542     (*env)->ReleaseStringUTFChars(env, str, s);
2543    
2544     return js;
2545     }
2546    
2547 zoff99 30 JNIEXPORT jint JNICALL
2548     Java_com_zoffcc_applications_zanavi_NavitGraphics_GetThreadId(JNIEnv* env, jobject thiz)
2549     {
2550     #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
2551 zoff99 40 dbg(0,"+#+:enter\n");
2552 zoff99 30 #endif
2553    
2554     int thread_id = gettid();
2555     // // dbg(0, "THREAD ID=%d\n", thread_id);
2556    
2557     jint i = thread_id;
2558     return i;
2559     }
2560    
2561 zoff99 2 JNIEXPORT void JNICALL
2562 zoff99 30 Java_com_zoffcc_applications_zanavi_NavitGraphics_CallbackMessageChannelReal(JNIEnv* env, jobject thiz, int i, jobject str2)
2563 zoff99 2 {
2564 zoff99 28 #ifdef NAVIT_FUNC_CALLS_DEBUG_PRINT
2565 zoff99 40 dbg(0,"+#+:enter\n");
2566 zoff99 28 #endif
2567 zoff99 30
2568 zoff99 40 __F_START__
2569    
2570 zoff99 30 int thread_id = gettid();
2571     // dbg(0, "THREAD ID=%d\n", thread_id);
2572    
2573 zoff99 40 #ifndef NAVIT_DEBUG_BAREMETAL
2574    
2575 zoff99 2 const char *s;
2576 zoff99 27 jobject str = (*env)->NewGlobalRef(env, str2);
2577 zoff99 2
2578     config_get_attr(config, attr_navit, &attr, NULL);
2579     // attr.u.navit
2580    
2581 zoff99 30 //DBG // dbg(0,"c1\n");
2582 zoff99 27
2583 zoff99 40
2584 zoff99 2 if (i)
2585     {
2586     if (i == 1)
2587     {
2588     // zoom in
2589     navit_zoom_in_cursor(global_navit, 2);
2590     // navit_zoom_in_cursor(attr.u.navit, 2);
2591     }
2592     else if (i == 2)
2593     {
2594     // zoom out
2595     navit_zoom_out_cursor(global_navit, 2);
2596     // navit_zoom_out_cursor(attr.u.navit, 2);
2597 zoff99 41 }
2598 zoff99 51 else if (i == 115)
2599     {
2600     // set test number
2601     s = (*env)->GetStringUTFChars(env, str, NULL);
2602     global_test_number = atoi(s);
2603     (*env)->ReleaseStringUTFChars(env, str, s);
2604     }
2605     else if (i == 114)
2606     {
2607     // set night mode 0|1
2608     s = (*env)->GetStringUTFChars(env, str, NULL);
2609     global_night_mode = atoi(s);
2610     (*env)->ReleaseStringUTFChars(env, str, s);
2611     }
2612 zoff99 50 else if (i == 113)
2613     {
2614     // cancel preview map drawing
2615     global_cancel_preview_map_drawing = 1;
2616     }
2617 zoff99 46 else if (i == 112)
2618     {
2619 zoff99 50 // show maps debug view (show maps on lower zoom levels)
2620 zoff99 46 s = (*env)->GetStringUTFChars(env, str, NULL);
2621     global_show_maps_debug_view = atoi(s);
2622     (*env)->ReleaseStringUTFChars(env, str, s);
2623     }
2624 zoff99 41 else if (i == 111)
2625     {
2626     // show real gps position on map
2627     s = (*env)->GetStringUTFChars(env, str, NULL);
2628     global_tracking_show_real_gps_pos = atoi(s);
2629     // dbg(0, "show_real_gps_pos=%d\n", global_tracking_show_real_gps_pos);
2630     (*env)->ReleaseStringUTFChars(env, str, s);
2631     }
2632     else if (i == 110)
2633     {
2634     // generic int option CallBack [<option name>:<option value "int">]
2635     s = (*env)->GetStringUTFChars(env, str, NULL);
2636 zoff99 34
2637 zoff99 41 char *str_copy = strdup(s);
2638     char *option_name = NULL;
2639     char *option_value = NULL;
2640    
2641     option_name = strsep(&str_copy, ":");
2642     option_value = strsep(&str_copy, ":");
2643    
2644     // dbg(0, "a=%s b=%s\n", option_name, option_value);
2645    
2646     /*
2647     street_0,living_street" speed="20" route_weight="20" route_prio_weight="30">
2648     street_1_city" speed="35" route_weight="35" route_prio_weight="30">
2649     track_paved" speed="35" route_weight="35" route_prio_weight="30">
2650     street_2_city,ramp_street_2_city" speed="50" route_weight="50" route_prio_weight="30">
2651     street_3_city,ramp_street_3_city" speed="50" route_weight="50" route_prio_weight="20">
2652     ramp_street_4_city" speed="49" route_weight="49" route_prio_weight="12">
2653     street_4_city" speed="50" route_weight="50" route_prio_weight="11">
2654     highway_city" speed="80" route_weight="80" route_prio_weight="9">
2655     street_1_land" speed="35" route_weight="35" route_prio_weight="30">
2656     street_2_land" speed="50" route_weight="50" route_prio_weight="11">
2657     street_3_land" speed="50" route_weight="50" route_prio_weight="11">
2658     street_4_land" speed="80" route_weight="80" route_prio_weight="11">
2659     street_n_lanes" speed="120" route_weight="120" route_prio_weight="9">
2660     ramp_highway_land" speed="119" route_weight="119" route_prio_weight="10">
2661     highway_land" speed="120" route_weight="120" route_prio_weight="9">
2662     */
2663    
2664     struct roadprofile *roadprofile = NULL;
2665     int value_ = 0;
2666    
2667     if (strcmp(option_name, "street_1_city#route_prio_weight") == 0)
2668     {
2669     roadprofile = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_1_city);
2670     if (roadprofile)
2671     {
2672     value_ = roadprofile->route_prio_weight;
2673     dbg(0, "VPR:old=%d\n", value_);
2674     roadprofile->route_prio_weight = atoi(option_value);
2675     dbg(0, "VPR:new=%d\n", roadprofile->route_prio_weight);
2676     vehicleprofile_change_roadprofile_attr(global_navit->vehicleprofile, roadprofile, type_street_1_city, roadprofile->route_prio_weight);
2677     }
2678    
2679    
2680     roadprofile = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_1_city);
2681     if (roadprofile)
2682     {
2683     value_ = roadprofile->route_prio_weight;
2684     dbg(0, "VPR:new2=%d\n", value_);
2685     }
2686     }
2687    
2688     // global_level2_announcement = atoi(option_value);
2689    
2690     g_free(str_copy);
2691    
2692     (*env)->ReleaseStringUTFChars(env, str, s);
2693 zoff99 2 }
2694 zoff99 41 else if (i == 109)
2695     {
2696     // level 2 announcement seconds
2697     s = (*env)->GetStringUTFChars(env, str, NULL);
2698     global_level2_announcement = (float)atoi(s) / 10.0f;
2699     (*env)->ReleaseStringUTFChars(env, str, s);
2700     }
2701     else if (i == 108)
2702     {
2703     // level 1 announcement seconds
2704     s = (*env)->GetStringUTFChars(env, str, NULL);
2705     global_level1_announcement = (float)atoi(s) / 10.0f;
2706     (*env)->ReleaseStringUTFChars(env, str, s);
2707     }
2708     else if (i == 107)
2709     {
2710     // level 0 announcement seconds
2711     s = (*env)->GetStringUTFChars(env, str, NULL);
2712     global_level0_announcement = (float)atoi(s) / 10.0f;
2713     (*env)->ReleaseStringUTFChars(env, str, s);
2714     }
2715     else if (i == 106)
2716     {
2717     // factor for routing/road speed
2718     s = (*env)->GetStringUTFChars(env, str, NULL);
2719     global_road_speed_factor = (float)atoi(s) / 100.0f;
2720     (*env)->ReleaseStringUTFChars(env, str, s);
2721     }
2722     else if (i == 105)
2723     {
2724     // zoom to specific zoomlevel without redrawing the map!
2725     s = (*env)->GetStringUTFChars(env, str, NULL);
2726     int zoom_level = atoi(s);
2727     navit_zoom_to_scale_no_draw(global_navit, zoom_level);
2728     (*env)->ReleaseStringUTFChars(env, str, s);
2729     }
2730     else if (i == 104)
2731     {
2732     // send OVERSPILL_FACTOR to C-code
2733     s = (*env)->GetStringUTFChars(env, str, NULL);
2734     int value = atoi(s);
2735    
2736     global_overspill_factor = (float)((float)value / 100.0f);
2737    
2738     (*env)->ReleaseStringUTFChars(env, str, s);
2739     }
2740     else if (i == 103)
2741     {
2742     // draw location of self (car) x% lower than screen center
2743     s = (*env)->GetStringUTFChars(env, str, NULL);
2744     int value = atoi(s);
2745    
2746     global_navit->radius = value;
2747    
2748     (*env)->ReleaseStringUTFChars(env, str, s);
2749     }
2750 zoff99 40 else if (i == 102)
2751     {
2752     // set gpsfix flag
2753     s = (*env)->GetStringUTFChars(env, str, NULL);
2754     int value = atoi(s);
2755    
2756     global_has_gpsfix = value;
2757    
2758     (*env)->ReleaseStringUTFChars(env, str, s);
2759     }
2760     else if (i == 101)
2761     {
2762     // set demo vehicle flag for tracking
2763     dbg(0, "DEMO VEHICLE* flag set\n");
2764     global_demo_vehicle_short_switch = 1;
2765     }
2766     else if (i == 100)
2767     {
2768     // dump callbacks to log
2769     callback_dump_callbacks();
2770     }
2771     else if (i == 99)
2772     {
2773     // set angle_pref value
2774     if (global_navit->tracking)
2775     {
2776     s = (*env)->GetStringUTFChars(env, str, NULL);
2777     int value = atoi(s);
2778    
2779     struct attr attr99;
2780     attr99.type = attr_angle_pref;
2781     attr99.u.num = value;
2782    
2783     tracking_set_attr(global_navit->tracking, &attr99);
2784    
2785     (*env)->ReleaseStringUTFChars(env, str, s);
2786     }
2787     }
2788     else if (i == 98)
2789     {
2790     // set connected_pref value
2791     if (global_navit->tracking)
2792     {
2793     s = (*env)->GetStringUTFChars(env, str, NULL);
2794     int value = atoi(s);
2795    
2796     struct attr attr99;
2797     attr99.type = attr_connected_pref;
2798     attr99.u.num = value;
2799    
2800     tracking_set_attr(global_navit->tracking, &attr99);
2801    
2802     (*env)->ReleaseStringUTFChars(env, str, s);
2803     }
2804     }
2805     else if (i == 97)
2806     {
2807     // set position to (lat#lon#name)
2808     char *name;
2809     s = (*env)->GetStringUTFChars(env, str, NULL);
2810     char parse_str[strlen(s) + 1];
2811     strcpy(parse_str, s);
2812     (*env)->ReleaseStringUTFChars(env, str, s);
2813    
2814     struct coord_geo g;
2815     char *p;
2816     char *stopstring;
2817    
2818     // lat
2819     p = strtok(parse_str, "#");
2820     g.lat = strtof(p, &stopstring);
2821     // lon
2822     p = strtok(NULL, "#");
2823     g.lng = strtof(p, &stopstring);
2824     // description
2825     name = strtok(NULL, "#");
2826    
2827     ////DBG // dbg(0,"lat=%f\n",g.lat);
2828     ////DBG // dbg(0,"lng=%f\n",g.lng);
2829     ////DBG // dbg(0,"str1=%s\n",name);
2830    
2831     struct coord c;
2832     transform_from_geo(projection_mg, &g, &c);
2833    
2834     struct pcoord pc;
2835     pc.x = c.x;
2836     pc.y = c.y;
2837     pc.pro = projection_mg;
2838    
2839     // set position
2840     navit_set_position(global_navit, &pc);
2841     }
2842     else if (i == 96)
2843     {
2844     // dump route to GPX file
2845     s = (*env)->GetStringUTFChars(env, str, NULL);
2846     if (global_navit->route)
2847     {
2848     if (global_navit->route->destinations)
2849     {
2850     navit_route_export_gpx_to_file(global_navit, s);
2851     }
2852     }
2853     (*env)->ReleaseStringUTFChars(env, str, s);
2854     }
2855     else if (i == 95)
2856     {
2857     // change priority for cycle tracks
2858     if (global_vehicle_profile == 1)
2859     {
2860     int old_value = global_cycle_track_prio;
2861     s = (*env)->GetStringUTFChars(env, str, NULL);
2862     global_cycle_track_prio = atoi(s);
2863    
2864     if (old_value != atoi(s))
2865     {
2866     if (global_navit->route)
2867     {
2868     if (global_navit->route->destinations)
2869     {
2870     route_path_update(global_navit->route, 1, 1);
2871     }
2872     }
2873     }
2874    
2875     (*env)->ReleaseStringUTFChars(env, str, s);
2876     }
2877     }
2878     else if (i == 94)
2879     {
2880     // change priority for cycle lanes
2881     if (global_vehicle_profile == 1)
2882     {
2883     int old_value = global_cycle_lanes_prio;
2884     s = (*env)->GetStringUTFChars(env, str, NULL);
2885     global_cycle_lanes_prio = atoi(s);
2886    
2887     if (old_value != atoi(s))
2888     {
2889     if (global_navit->route)
2890     {
2891     if (global_navit->route->destinations)
2892     {
2893     route_path_update(global_navit->route, 1, 1);
2894     }
2895     }
2896     }
2897    
2898     (*env)->ReleaseStringUTFChars(env, str, s);
2899     }
2900     }
2901     else if (i == 93)
2902     {
2903     // change vehicle profile's roadprofile values 003
2904    
2905     if (global_vehicle_profile == 1)
2906     {
2907    
2908     int old_value = 0;
2909     s = (*env)->GetStringUTFChars(env, str, NULL);
2910    
2911     struct roadprofile *rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_3_land);
2912    
2913     if (rp)
2914     {
2915     old_value = rp->route_prio_weight;
2916     }
2917    
2918     if (rp)
2919     {
2920     rp->route_prio_weight = atoi(s);
2921     }
2922    
2923     rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_4_land);
2924     if (rp)
2925     {
2926     rp->route_prio_weight = atoi(s);
2927     }
2928    
2929     // calc route new!
2930     if (rp)
2931     {
2932     if (old_value != atoi(s))
2933     {
2934     if (global_navit->route)
2935     {
2936     if (global_navit->route->destinations)
2937     {
2938     route_path_update(global_navit->route, 1, 1);
2939     }
2940     }
2941     }
2942     }
2943    
2944     (*env)->ReleaseStringUTFChars(env, str, s);
2945     }
2946    
2947     }
2948     else if (i == 92)
2949     {
2950     // change vehicle profile's roadprofile values 002
2951    
2952     if (global_vehicle_profile == 1)
2953     {
2954    
2955     int old_value = 0;
2956     s = (*env)->GetStringUTFChars(env, str, NULL);
2957    
2958     struct roadprofile *rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_3_city);
2959    
2960     if (rp)
2961     {
2962     old_value = rp->route_prio_weight;
2963     }
2964    
2965     if (rp)
2966     {
2967     rp->route_prio_weight = atoi(s);
2968     }
2969    
2970     rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_4_city);
2971     if (rp)
2972     {
2973     rp->route_prio_weight = atoi(s);
2974     }
2975    
2976 zoff99 41 //rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_ramp);
2977     //if (rp)
2978     //{
2979     // rp->route_prio_weight = atoi(s);
2980     //}
2981 zoff99 40
2982     // calc route new!
2983     if (rp)
2984     {
2985     if (old_value != atoi(s))
2986     {
2987     if (global_navit->route)
2988     {
2989     if (global_navit->route->destinations)
2990     {
2991     route_path_update(global_navit->route, 1, 1);
2992     }
2993     }
2994     }
2995     }
2996    
2997     (*env)->ReleaseStringUTFChars(env, str, s);
2998     }
2999    
3000     }
3001     else if (i == 91)
3002     {
3003     // change vehicle profile's roadprofile values 001
3004    
3005     if (global_vehicle_profile == 1)
3006     {
3007    
3008     int old_value = 0;
3009     s = (*env)->GetStringUTFChars(env, str, NULL);
3010    
3011     struct roadprofile *rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_2_city);
3012    
3013     if (rp)
3014     {
3015     old_value = rp->route_prio_weight;
3016     }
3017    
3018     if (rp)
3019     {
3020     rp->route_prio_weight = atoi(s);
3021     }
3022    
3023     rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_1_land);
3024     if (rp)
3025     {
3026     rp->route_prio_weight = atoi(s);
3027     }
3028    
3029     rp = vehicleprofile_get_roadprofile(global_navit->vehicleprofile, type_street_2_land);
3030     if (rp)
3031     {
3032     rp->route_prio_weight = atoi(s);
3033     }
3034    
3035     // calc route new!
3036     if (rp)
3037     {
3038     if (old_value != atoi(s))
3039     {
3040     if (global_navit->route)
3041     {
3042     if (global_navit->route->destinations)
3043     {
3044     route_path_update(global_navit->route, 1, 1);
3045     }
3046     }
3047     }
3048     }
3049    
3050     (*env)->ReleaseStringUTFChars(env, str, s);
3051    
3052     // <roadprofile item_types="street_0,street_1_city,living_street" speed="20" route_weight="20" route_prio_weight="2">
3053     // <roadprofile item_types="street_2_city,street_1_land,street_2_land" speed="15" route_weight="15" route_prio_weight="90">
3054    
3055     }
3056    
3057     }
3058     else if (i == 90)
3059     {
3060     // set vehicleprofile to value of string s ('car','bike')
3061     s = (*env)->GetStringUTFChars(env, str, NULL);
3062     if (!navit_set_vehicleprofile(global_navit, s))
3063     {
3064     }
3065     else
3066     {
3067     if (!strcmp(s, "car"))
3068     {
3069     global_vehicle_profile = 0; // car
3070 zoff99 41
3071     if (global_enhance_cycleway == 1)
3072     {
3073     navit_reset_cycleway(global_navit);
3074     }
3075 zoff99 40 }
3076     else if (!strcmp(s, "bike-normal"))
3077     {
3078     global_vehicle_profile = 1; // bicycle
3079 zoff99 41
3080     if (global_enhance_cycleway == 0)
3081     {
3082     navit_enhance_cycleway(global_navit);
3083     }
3084 zoff99 40 }
3085     else if (!strcmp(s, "bike-avoid-roads"))
3086     {
3087     global_vehicle_profile = 1; // bicycle
3088 zoff99 41
3089     if (global_enhance_cycleway == 0)
3090     {
3091     navit_enhance_cycleway(global_navit);
3092     }
3093 zoff99 40 }
3094     else if (!strcmp(s, "bike-no-oneway"))
3095     {
3096     global_vehicle_profile = 2; // bicycle no one-way!
3097 zoff99 41
3098     if (global_enhance_cycleway == 0)
3099     {
3100     navit_enhance_cycleway(global_navit);
3101     }
3102 zoff99 40 }
3103     else
3104     {
3105     global_vehicle_profile = 0; // car
3106 zoff99 41
3107     if (global_enhance_cycleway == 1)
3108     {
3109     navit_reset_cycleway(global_navit);
3110     }
3111 zoff99 40 }
3112     // dbg(0, "global_vehicle_profile=%d\n", global_vehicle_profile);
3113     }
3114     (*env)->ReleaseStringUTFChars(env, str, s);
3115     }
3116     else if (i == 89)
3117     {
3118     // search this far around street-coord to find potential housenumbers for this street
3119     s = (*env)->GetStringUTFChars(env, str, NULL);
3120     global_search_radius_for_housenumbers = atoi(s);
3121     (*env)->ReleaseStringUTFChars(env, str, s);
3122     }
3123     else if (i == 88)
3124     {
3125     // avoid sharp turns penalty
3126     s = (*env)->GetStringUTFChars(env, str, NULL);
3127     global_avoid_sharp_turns_min_penalty = atoi(s);
3128     (*env)->ReleaseStringUTFChars(env, str, s);
3129     }
3130     else if (i == 87)
3131     {
3132     // avoid sharp turns minimum angle. if turn is harder than this angle then set penalty
3133     s = (*env)->GetStringUTFChars(env, str, NULL);
3134     global_avoid_sharp_turns_min_angle = atoi(s);
3135     (*env)->ReleaseStringUTFChars(env, str, s);
3136     }
3137     else if (i == 86)
3138     {
3139     // avoid sharp turns flag to 0 or 1
3140     s = (*env)->GetStringUTFChars(env, str, NULL);
3141     global_avoid_sharp_turns_flag = atoi(s);
3142     (*env)->ReleaseStringUTFChars(env, str, s);
3143     }
3144     else if (i == 85)
3145     {
3146     // C-linedrawing flag to 0 or 1
3147     s = (*env)->GetStringUTFChars(env, str, NULL);
3148     global_clinedrawing_active = atoi(s);
3149     (*env)->ReleaseStringUTFChars(env, str, s);
3150     }
3151 zoff99 34 else if (i == 84)
3152     {
3153     // report data dir
3154     s = (*env)->GetStringUTFChars(env, str, NULL);
3155     navit_data_dir = g_strdup(s);
3156     (*env)->ReleaseStringUTFChars(env, str, s);
3157     }
3158     else if (i == 83)
3159     {
3160     // spill all the index files to log output
3161     spill_index();
3162     }
3163     else if (i == 82)
3164     {
3165     // report share dir
3166     s = (*env)->GetStringUTFChars(env, str, NULL);
3167     navit_share_dir = g_strdup(s);
3168     (*env)->ReleaseStringUTFChars(env, str, s);
3169     }
3170     else if (i == 81)
3171     {
3172     // resize layout items by factor
3173     s = (*env)->GetStringUTFChars(env, str, NULL);
3174     displaylist_shift_for_dpi_value_in_layers(global_navit, (double)(atof(s)));
3175     (*env)->ReleaseStringUTFChars(env, str, s);
3176     }
3177     else if (i == 80)
3178     {
3179     // autozoom flag to 0 or 1
3180     s = (*env)->GetStringUTFChars(env, str, NULL);
3181     global_navit->autozoom_active = atoi(s);
3182     (*env)->ReleaseStringUTFChars(env, str, s);
3183     }
3184 zoff99 31 else if (i == 79)
3185     {
3186     // set traffic light delay
3187     s = (*env)->GetStringUTFChars(env, str, NULL);
3188     global_traffic_light_delay = atoi(s);
3189     (*env)->ReleaseStringUTFChars(env, str, s);
3190     }
3191     else if (i == 78)
3192     {
3193     // shift layout "order" values
3194     s = (*env)->GetStringUTFChars(env, str, NULL);
3195     displaylist_shift_order_in_map_layers(global_navit, atoi(s));
3196     (*env)->ReleaseStringUTFChars(env, str, s);
3197     }
3198     else if (i == 77)
3199     {
3200     // do not show route rectangles
3201     global_show_route_rectangles = 0;
3202     }
3203     else if (i == 76)
3204     {
3205     // show route rectangles
3206     global_show_route_rectangles = 1;
3207     }
3208 zoff99 30 else if (i == 75)
3209     {
3210     // stop demo vechile
3211     global_stop_demo_vehicle = 1;
3212     }
3213     else if (i == 74)
3214     {
3215     // allow demo vechile to move
3216     global_stop_demo_vehicle = 0;
3217     }
3218 zoff99 28 else if (i == 73)
3219     {
3220     // update the route path and route graph (e.g. after setting new roadblocks)
3221     // this destroys the route graph and calcs everything totally new!
3222     if (global_navit->route)
3223     {
3224     if (global_navit->route->destinations)
3225     {
3226     route_path_update(global_navit->route, 1, 1);
3227     }
3228     }
3229     }
3230     else if (i == 72)
3231     {
3232     // update the route path and route graph (e.g. after setting new roadblocks)
3233     // does not update destinations!!!
3234     if (global_navit->route)
3235     {
3236     if (global_navit->route->destinations)
3237     {
3238     route_path_update(global_navit->route, 0, 1);
3239     }
3240     }
3241     }
3242     else if (i == 71)
3243     {
3244     // activate/deactivate "route graph" display
3245     // 0 -> deactivate
3246     // 1 -> activate
3247    
3248     // _ms_route_graph
3249     // _ms_navigation
3250     s = (*env)->GetStringUTFChars(env, str, NULL);
3251     navit_map_active_flag(global_navit, atoi(s), "_ms_route_graph");
3252 zoff99 40 navit_map_active_flag(global_navit, atoi(s), "_ms_navigation");
3253 zoff99 28 (*env)->ReleaseStringUTFChars(env, str, s);
3254     }
3255     else if (i == 70)
3256     {
3257     // allow drawing map
3258     hold_drawing = 0;
3259     }
3260     else if (i == 69)
3261     {
3262     // stop drawing map
3263     hold_drawing = 1;
3264     }
3265     else if (i == 68)
3266     {
3267     // shift "order" by this value (only for drawing objects)
3268     s = (*env)->GetStringUTFChars(env, str, NULL);
3269     shift_order = atoi(s);
3270     (*env)->ReleaseStringUTFChars(env, str, s);
3271     }
3272     else if (i == 67)
3273     {
3274 zoff99 31 // disable "multipolygons"
3275     global_draw_multipolygons = 0;
3276 zoff99 28 }
3277     else if (i == 66)
3278     {
3279 zoff99 31 // enable "multipolygons"
3280     global_draw_multipolygons = 1;
3281 zoff99 28 }
3282     else if (i == 65)
3283     {
3284     // draw map async
3285     navit_draw_async(global_navit, 1);
3286     }
3287     else if (i == 64)
3288     {
3289     // draw map
3290     navit_draw(global_navit);
3291     }
3292     else if (i == 63)
3293     {
3294     // enable map drawing
3295     disable_map_drawing = 0;
3296     }
3297     else if (i == 62)
3298     {
3299     // disable map drawing
3300     disable_map_drawing = 1;
3301     }
3302     else if (i == 61)
3303     {
3304     // zoom to specific zoomlevel at given point as center
3305     struct point p;
3306     char *pstr;
3307    
3308     s = (*env)->GetStringUTFChars(env, str, NULL);
3309     char parse_str[strlen(s) + 1];
3310     strcpy(parse_str, s);
3311     (*env)->ReleaseStringUTFChars(env, str, s);
3312     // (pixel-x#pixel-y#zoom-level)
3313     // pixel-x
3314     pstr = strtok(parse_str, "#");
3315     p.x = atoi(pstr);
3316     // pixel-y
3317     pstr = strtok(NULL, "#");
3318     p.y = atoi(pstr);
3319     // zoom
3320     pstr = strtok(NULL, "#");
3321     int zoom_level = atoi(pstr);
3322     // now call zoom function
3323     navit_zoom_to_scale_with_center_point(global_navit, zoom_level, &p);
3324     }
3325     else if (i == 60)
3326     {
3327     // disable layer "name"
3328     s = (*env)->GetStringUTFChars(env, str, NULL);
3329     navit_layer_set_active(global_navit, s, 0, 0);
3330     (*env)->ReleaseStringUTFChars(env, str, s);
3331     }
3332     else if (i == 59)
3333     {
3334     // enable layer "name"
3335     s = (*env)->GetStringUTFChars(env, str, NULL);
3336     navit_layer_set_active(global_navit, s, 1, 0);
3337     (*env)->ReleaseStringUTFChars(env, str, s);
3338     }
3339 zoff99 27 else if (i == 58)
3340     {
3341     // make street search radius bigger to the factor "s"
3342     s = (*env)->GetStringUTFChars(env, str, NULL);
3343     global_search_street_size_factor = atoi(s);
3344     (*env)->ReleaseStringUTFChars(env, str, s);
3345     }
3346     else if (i == 57)
3347     {
3348     // keep drawing streets as if at "order" level xxx
3349     s = (*env)->GetStringUTFChars(env, str, NULL);
3350     limit_order_corrected = atoi(s);
3351     (*env)->ReleaseStringUTFChars(env, str, s);
3352     }
3353     else if (i == 56)
3354     {
3355     // draw polylines with/without circles at the end
3356 zoff99 30 //// dbg(0, "dpf1\n");
3357 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3358 zoff99 30 //// dbg(0, "dpf2\n");
3359 zoff99 27 draw_polylines_fast = atoi(s);
3360 zoff99 30 //// dbg(0, "dpf=%d\n", draw_polylines_fast);
3361 zoff99 27 (*env)->ReleaseStringUTFChars(env, str, s);
3362     }
3363     else if (i == 55)
3364     {
3365     // set cache size for (map-)files
3366 zoff99 30 //// dbg(0, "csf1\n");
3367 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3368 zoff99 30 //// dbg(0, "csf2\n");
3369 zoff99 27 cache_size_file = atoi(s);
3370     file_cache_init();
3371 zoff99 30 // dbg(0, "csf=%d\n", cache_size_file);
3372 zoff99 27 (*env)->ReleaseStringUTFChars(env, str, s);
3373     }
3374     else if (i == 54)
3375     {
3376     // speak streetnames
3377     global_speak_streetnames = 1;
3378     }
3379     else if (i == 53)
3380     {
3381     // dont speak streetnames
3382     global_speak_streetnames = 0;
3383     }
3384     else if (i == 52)
3385     {
3386     // switch to demo vehicle
3387 zoff99 28
3388     s = (*env)->GetStringUTFChars(env, str, NULL);
3389    
3390 zoff99 40 dbg(0, "**SWITCH TO:DEMO VEHICLE**\n");
3391     global_demo_vehicle_short_switch = 0;
3392     global_demo_vehicle = 1;
3393    
3394 zoff99 27 if (global_navit->vehicle)
3395     {
3396     navit_remove_cursors(global_navit);
3397     vehicle_destroy(global_navit->vehicle->vehicle);
3398     global_navit->vehicles = NULL;
3399     global_navit->vehicle = NULL;
3400     }
3401    
3402     struct attr parent;
3403     struct attr source;
3404     struct attr active;
3405     struct attr follow;
3406     struct attr speed;
3407     struct attr interval;
3408     struct attr *attrs[6];
3409     parent.type = attr_navit;
3410     parent.u.navit = global_navit;
3411    
3412     source.type = attr_source;
3413     source.u.str = "demo://";
3414    
3415     active.type = attr_active;
3416     active.u.num = 1;
3417    
3418     follow.type = attr_follow;
3419     follow.u.num = 1;
3420    
3421     speed.type = attr_speed;
3422    
3423 zoff99 40 if ((global_vehicle_profile == 1) || (global_vehicle_profile == 2))
3424     {
3425 zoff99 41 // for bicycle it's always 27 km/h
3426     speed.u.num = 27;
3427 zoff99 40 }
3428     else
3429     {
3430     // should be 45 km/h
3431     speed.u.num = atoi(s);
3432     }
3433    
3434 zoff99 27 interval.type = attr_interval;
3435 zoff99 30 interval.u.num = 1000; // 1 sec.
3436     // interval.u.num = 5000; // 5 sec.
3437 zoff99 27
3438     attrs[0] = &source;
3439     attrs[1] = &active;
3440     attrs[2] = &follow;
3441     attrs[3] = &speed;
3442     attrs[4] = &interval;
3443     attrs[5] = NULL;
3444     // attr_source -> source->u.str='demo://'
3445     // <!-- vehicle name="Demo" profilename="car" enabled="no" active="yes" source="demo://" -->
3446     struct vehicle *v;
3447 zoff99 30 //DBG // dbg(0, "demo vehicle new start\n");
3448 zoff99 27 v = vehicle_new(&parent, attrs);
3449 zoff99 30 //DBG // dbg(0, "demo vehicle new end\n");
3450 zoff99 27
3451     if (v != NULL)
3452     {
3453 zoff99 30 //DBG // dbg(0, "adding demo vehicle\n");
3454 zoff99 27 navit_add_vehicle(global_navit, v);
3455 zoff99 30 //DBG // dbg(0, "setting cursor\n");
3456 zoff99 27 navit_set_cursors(global_navit);
3457    
3458     struct attr follow2;
3459     follow2.type = attr_follow;
3460     follow2.u.num = 1;
3461     navit_set_attr(global_navit, &follow2);
3462    
3463     // switch "Map follows Vehicle" ON
3464     struct attr attrx;
3465     attrx.type = attr_follow_cursor;
3466     attrx.u.num = 1;
3467     navit_set_attr(global_navit, &attrx);
3468     }
3469     else
3470     {
3471 zoff99 30 //DBG // dbg(0, "ERROR adding demo vehicle\n");
3472 zoff99 27 }
3473     // **no** navit_set_vehicle(global_navit, global_navit->vehicle);
3474 zoff99 30 //DBG // dbg(0, "ready\n");
3475 zoff99 28
3476     (*env)->ReleaseStringUTFChars(env, str, s);
3477 zoff99 27 }
3478     else if (i == 51)
3479     {
3480     // set position to pixel x,y
3481 zoff99 30 //DBG // dbg(0, "sp 1\n");
3482 zoff99 27 char *pstr;
3483     struct point p;
3484     struct coord c;
3485     struct pcoord pc;
3486    
3487     s = (*env)->GetStringUTFChars(env, str, NULL);
3488     char parse_str[strlen(s) + 1];
3489     strcpy(parse_str, s);
3490     (*env)->ReleaseStringUTFChars(env, str, s);
3491    
3492     // (pixel-x#pixel-y)
3493     // pixel-x
3494     pstr = strtok(parse_str, "#");
3495     p.x = atoi(pstr);
3496     // pixel-y
3497     pstr = strtok(NULL, "#");
3498     p.y = atoi(pstr);
3499    
3500 zoff99 30 //DBG // dbg(0, "sp 2\n");
3501 zoff99 27 transform_reverse(global_navit->trans, &p, &c);
3502 zoff99 30 //DBG // dbg(0, "sp 3\n");
3503 zoff99 27
3504     pc.x = c.x;
3505     pc.y = c.y;
3506 zoff99 30 //DBG // dbg(0, "sp 4\n");
3507 zoff99 27 pc.pro = transform_get_projection(global_navit->trans);
3508 zoff99 30 //DBG // dbg(0, "sp 5\n");
3509 zoff99 27
3510 zoff99 30 //DBG // dbg(0, "%d %d\n", pc.x, pc.y);
3511 zoff99 27 // set position
3512 zoff99 30 //DBG // dbg(0, "sp 6\n");
3513 zoff99 27 navit_set_position(global_navit, &pc);
3514 zoff99 30 //DBG // dbg(0, "ready\n");
3515 zoff99 27 }
3516     else if (i == 50)
3517     {
3518     // we request to stop drawing the map
3519 zoff99 30 // dbg(0, "DO__DRAW:cancel_drawing_global=1\n");
3520 zoff99 27 cancel_drawing_global = 1;
3521     }
3522     else if (i == 47)
3523     {
3524     // change maps data dir
3525     s = (*env)->GetStringUTFChars(env, str, NULL);
3526     navit_maps_dir = g_strdup(s);
3527     (*env)->ReleaseStringUTFChars(env, str, s);
3528 zoff99 30 // //DBG // dbg(0,"*****string use=%s\n",navit_maps_dir);
3529 zoff99 27 }
3530 zoff99 15 else if (i == 46)
3531     {
3532     // stop searching and show results found until now
3533 zoff99 27 offline_search_break_searching = 1;
3534 zoff99 15 }
3535     else if (i == 45)
3536     {
3537     // filter duplicates in search results
3538 zoff99 27 offline_search_filter_duplicates = 1;
3539 zoff99 15 }
3540     else if (i == 44)
3541     {
3542     // show duplicates in search results
3543 zoff99 27 offline_search_filter_duplicates = 0;
3544 zoff99 15 }
3545 zoff99 2 else if (i == 43)
3546     {
3547     // routing mode "normal roads"
3548 zoff99 27 routing_mode = 1;
3549 zoff99 2 }
3550     else if (i == 42)
3551     {
3552     // routing mode "highways"
3553 zoff99 27 routing_mode = 0;
3554 zoff99 2 }
3555     else if (i == 41)
3556     {
3557     // switch "Map follows Vehicle" OFF
3558     struct attr attrx;
3559 zoff99 27 attrx.type = attr_follow_cursor;
3560     attrx.u.num = 0;
3561     navit_set_attr(global_navit, &attrx);
3562 zoff99 2 }
3563     else if (i == 40)
3564     {
3565     // switch "Map follows Vehicle" ON
3566     struct attr attrx;
3567 zoff99 27 attrx.type = attr_follow_cursor;
3568     attrx.u.num = 1;
3569     navit_set_attr(global_navit, &attrx);
3570 zoff99 2 }
3571     else if (i == 39)
3572     {
3573     // switch "Northing" OFF
3574     struct attr attrx;
3575 zoff99 27 attrx.type = attr_orientation;
3576     attrx.u.num = 0;
3577     navit_set_attr(global_navit, &attrx);
3578 zoff99 2 }
3579     else if (i == 38)
3580     {
3581     // switch "Northing" ON
3582     struct attr attrx;
3583 zoff99 27 attrx.type = attr_orientation;
3584     attrx.u.num = 1;
3585     navit_set_attr(global_navit, &attrx);
3586 zoff99 2 }
3587     else if (i == 37)
3588     {
3589     // switch "Lock on road" OFF
3590     struct attr attrx;
3591 zoff99 27 attrx.type = attr_tracking;
3592     attrx.u.num = 0;
3593     navit_set_attr(global_navit, &attrx);
3594 zoff99 2 }
3595     else if (i == 36)
3596     {
3597     // switch "Lock on road" ON
3598     struct attr attrx;
3599 zoff99 27 attrx.type = attr_tracking;
3600     attrx.u.num = 1;
3601     navit_set_attr(global_navit, &attrx);
3602 zoff99 2 }
3603     else if (i == 35)
3604     {
3605     // announcer voice ON
3606     navit_cmd_announcer_on(global_navit);
3607     }
3608     else if (i == 34)
3609     {
3610     // announcer voice OFF
3611     navit_cmd_announcer_off(global_navit);
3612     }
3613     else if (i == 33)
3614     {
3615     // zoom to specific zoomlevel
3616 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3617 zoff99 2 int zoom_level = atoi(s);
3618     navit_zoom_to_scale(global_navit, zoom_level);
3619     (*env)->ReleaseStringUTFChars(env, str, s);
3620     }
3621     else if (i == 32)
3622     {
3623     // switch to specific 3D pitch
3624     struct attr pitch_attr;
3625 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3626     pitch_attr.type = attr_pitch;
3627 zoff99 2 pitch_attr.u.num = atoi(s);
3628 zoff99 27 navit_set_attr(global_navit, &pitch_attr);
3629 zoff99 2 (*env)->ReleaseStringUTFChars(env, str, s);
3630     }
3631     else if (i == 31)
3632     {
3633     // switch to 3D
3634     struct attr pitch_attr;
3635 zoff99 27 pitch_attr.type = attr_pitch;
3636     pitch_attr.u.num = 30;
3637     navit_set_attr(global_navit, &pitch_attr);
3638 zoff99 2 }
3639     else if (i == 30)
3640     {
3641     // switch to 2D
3642     struct attr pitch_attr;
3643 zoff99 27 pitch_attr.type = attr_pitch;
3644     pitch_attr.u.num = 0;
3645     navit_set_attr(global_navit, &pitch_attr);
3646 zoff99 2 }
3647     // 21 - 25 are used in java, so leave a hole here to make it easier to understand
3648 zoff99 27
3649 zoff99 2 else if (i == 20)
3650     {
3651     // add all scdard maps
3652     navit_add_all_maps(global_navit);
3653 zoff99 40 // get the current vehicle position to the route struct -> set effective starting position for routing
3654     navit_set_vehicle_position_to_screen_center_only_for_route_struct(global_navit);
3655 zoff99 2 }
3656     else if (i == 19)
3657     {
3658     // remove all scdard maps
3659     navit_remove_all_maps(global_navit);
3660     }
3661     else if (i == 18)
3662     {
3663     // reload scdard maps
3664     navit_reload_maps(global_navit);
3665     }
3666     else if (i == 17)
3667     {
3668     // zoom to route
3669     navit_zoom_to_route(global_navit, 0);
3670 zoff99 40
3671     // return new zoom level to android
3672     long scale = transform_get_scale(global_navit->trans);
3673     dbg(0, "A:new scale=%lld\n", scale);
3674     android_return_generic_int(3, (int) scale);
3675 zoff99 2 }
3676     else if (i == 16)
3677     {
3678     // use imperial units
3679 zoff99 27 global_navit->imperial = 1;
3680 zoff99 2 }
3681     else if (i == 15)
3682     {
3683     // use metric units
3684 zoff99 27 global_navit->imperial = 0;
3685 zoff99 2 }
3686     else if (i == 14)
3687     {
3688     // draw location of self (car) in the screen center
3689 zoff99 27 global_navit->radius = 0;
3690 zoff99 2 }
3691     else if (i == 13)
3692     {
3693     // draw location of self (car) 30% lower than screen center
3694 zoff99 27 global_navit->radius = 30;
3695 zoff99 2 }
3696     else if (i == 12)
3697     {
3698     // draw map only at speeds higher than 5 km/h
3699     struct attr static_speed_attr;
3700 zoff99 27 static_speed_attr.type = attr_static_speed;
3701     static_speed_attr.u.num = 5;
3702 zoff99 2 vehicleprofile_set_attr(global_navit->vehicleprofile, &static_speed_attr);
3703     }
3704     else if (i == 11)
3705     {
3706     // allow redraw map at ZERO speed
3707     struct attr static_speed_attr;
3708 zoff99 27 static_speed_attr.type = attr_static_speed;
3709     static_speed_attr.u.num = 0;
3710 zoff99 2 vehicleprofile_set_attr(global_navit->vehicleprofile, &static_speed_attr);
3711     }
3712     else if (i == 10)
3713     {
3714     // allow internal GUI
3715     allow_gui_internal = 1;
3716     }
3717     else if (i == 9)
3718     {
3719     // disable internal GUI
3720     allow_gui_internal = 0;
3721     }
3722     else if (i == 8)
3723     {
3724     // zoom to zoomlevel
3725 zoff99 30 //DBG // dbg(0,"-8- a\n");
3726 zoff99 2 navit_zoom_to_scale(global_navit, 524288);
3727 zoff99 30 //DBG // dbg(0,"-8- b\n");
3728 zoff99 2 }
3729     else if (i == 7)
3730     {
3731     // stop navigation
3732     if (attr.u.navit->destination_valid != 0)
3733     {
3734     navit_set_destination(&attr.u.navit->self, NULL, NULL, 0);
3735 zoff99 31 #ifdef DEBUG_GLIB_MEM_FUNCTIONS
3736     g_mem_profile();
3737     #endif
3738 zoff99 2 }
3739     }
3740 zoff99 27 else if (i == 6)
3741 zoff99 2 {
3742     // not used now!
3743     }
3744 zoff99 27 else if (i == 5)
3745 zoff99 2 {
3746 zoff99 40 // toggle layer on/off
3747 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3748 zoff99 40 navit_layer_toggle_active(global_navit, s, 1);
3749 zoff99 2 (*env)->ReleaseStringUTFChars(env, str, s);
3750     }
3751 zoff99 27 else if (i == 49)
3752     {
3753     // add waypoint at pixel x,y on screen
3754    
3755     char *pstr;
3756     struct point p;
3757     struct coord c;
3758     struct pcoord pc;
3759    
3760     s = (*env)->GetStringUTFChars(env, str, NULL);
3761     char parse_str[strlen(s) + 1];
3762     strcpy(parse_str, s);
3763     (*env)->ReleaseStringUTFChars(env, str, s);
3764    
3765     // add waypoint (pixel-x#pixel-y)
3766     // pixel-x
3767     pstr = strtok(parse_str, "#");
3768     p.x = atoi(pstr);
3769     // pixel-y
3770     pstr = strtok(NULL, "#");
3771     p.y = atoi(pstr);
3772    
3773     transform_reverse(global_navit->trans, &p, &c);
3774    
3775     pc.x = c.x;
3776     pc.y = c.y;
3777     pc.pro = transform_get_projection(global_navit->trans);
3778    
3779     // append new waypoint to navigation
3780     navit_add_waypoint_to_route(global_navit, &pc, parse_str, 1);
3781     }
3782 zoff99 2 else if (i == 4)
3783     {
3784     // set destination to pixel x,y on screen
3785    
3786     char *pstr;
3787     struct point p;
3788     struct coord c;
3789     struct pcoord pc;
3790    
3791 zoff99 27 s = (*env)->GetStringUTFChars(env, str, NULL);
3792 zoff99 2 char parse_str[strlen(s) + 1];
3793     strcpy(parse_str, s);
3794     (*env)->ReleaseStringUTFChars(env, str, s);
3795    
3796     // set destination to (pixel-x#pixel-y)
3797     // pixel-x
3798 zoff99 27 pstr = strtok(parse_str, "#");
3799 zoff99 2 p.x = atoi(pstr);
3800     // pixel-y
3801 zoff99 27 pstr = strtok(NULL, "#");
3802 zoff99 2 p.y = atoi(pstr);
3803    
3804     transform_reverse(global_navit->trans, &p, &c);
3805    
3806     pc.x = c.x;
3807     pc.y = c.y;
3808     pc.pro = transform_get_projection(global_navit->trans);
3809    
3810     // start navigation asynchronous
3811     navit_set_destination(global_navit, &pc, parse_str, 1);
3812     }
3813 zoff99 41 else if (i == 55548)
3814     {
3815     // append waypoint at lat, lng
3816    
3817     char *name;
3818     s = (*env)->GetStringUTFChars(env, str, NULL);
3819     char parse_str[strlen(s) + 1];
3820     strcpy(parse_str, s);
3821     (*env)->ReleaseStringUTFChars(env, str, s);
3822    
3823     // waypoint (lat#lon#title)
3824     struct coord_geo g;
3825     char *p;
3826     char *stopstring;
3827    
3828     // lat
3829     p = strtok(parse_str, "#");
3830     g.lat = strtof(p, &stopstring);
3831     // lon
3832     p = strtok(NULL, "#");
3833     g.lng = strtof(p, &stopstring);
3834     // description
3835     name = strtok(NULL, "#");
3836    
3837     ////DBG // dbg(0,"lat=%f\n",g.lat);
3838     ////DBG // dbg(0,"lng=%f\n",g.lng);
3839     ////DBG // dbg(0,"str1=%s\n",name);
3840    
3841     struct coord c;
3842     transform_from_geo(projection_mg, &g, &c);
3843    
3844     struct pcoord pc;
3845     pc.x = c.x;
3846     pc.y = c.y;
3847     pc.pro = projection_mg;
3848    
3849     if (global_navit->destination_valid == 1)
3850     {
3851     route_add_destination_no_calc(global_navit->route, &pc, 1);
3852    
3853     global_navit->destination = pc;
3854     global_navit->destination_valid = 1;
3855     }
3856