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

Contents of /navit/navit/android.c

Parent Directory Parent Directory | Revision Log Revision Log


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