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

Contents of /navit/navit/graphics/android/graphics_android.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 56 - (hide annotations) (download)
Sun Mar 19 08:44:36 2017 UTC (3 years, 4 months ago) by zoff99
File MIME type: text/plain
File size: 77067 byte(s)
updates
1 zoff99 2 /**
2 zoff99 27 * ZANavi, Zoff Android Navigation system.
3     * Copyright (C) 2011-2012 Zoff <zoff@zoff.cc>
4     *
5     * This program is free software; you can redistribute it and/or
6     * modify it under the terms of the GNU General Public License
7     * version 2 as published by the Free Software Foundation.
8     *
9     * This program is distributed in the hope that it will be useful,
10     * but WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12     * GNU General Public License for more details.
13     *
14     * You should have received a copy of the GNU General Public License
15     * along with this program; if not, write to the
16     * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17     * Boston, MA 02110-1301, USA.
18     */
19    
20     /**
21 zoff99 2 * Navit, a modular navigation system.
22     * Copyright (C) 2005-2008 Navit Team
23     *
24     * This program is free software; you can redistribute it and/or
25     * modify it under the terms of the GNU General Public License
26     * version 2 as published by the Free Software Foundation.
27     *
28     * This program is distributed in the hope that it will be useful,
29     * but WITHOUT ANY WARRANTY; without even the implied warranty of
30     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31     * GNU General Public License for more details.
32     *
33     * You should have received a copy of the GNU General Public License
34     * along with this program; if not, write to the
35     * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
36     * Boston, MA 02110-1301, USA.
37     */
38    
39 zoff99 40 #include <errno.h>
40    
41 zoff99 2 #include <unistd.h>
42 zoff99 40 #include <stdlib.h>
43     #include <math.h>
44 zoff99 2 #include <glib.h>
45     #include "config.h"
46     #include "window.h"
47     #include "point.h"
48     #include "graphics.h"
49     #include "color.h"
50     #include "plugin.h"
51     #include "event.h"
52     #include "debug.h"
53     #include "callback.h"
54 zoff99 40 #include <android/bitmap.h>
55 zoff99 2 #include "android.h"
56    
57     int dummy;
58    
59 zoff99 30 jclass NavitClass2 = NULL;
60     jmethodID Navit_get_graphics_object_by_name;
61    
62 zoff99 27 struct graphics_priv
63     {
64 zoff99 2 jclass NavitGraphicsClass;
65 zoff99 27 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,
66 zoff99 34 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;
67 zoff99 2
68     jclass PaintClass;
69 zoff99 27 jmethodID Paint_init, Paint_setStrokeWidth, Paint_setARGB;
70 zoff99 2
71     jobject NavitGraphics;
72     jobject Paint;
73 zoff99 27
74     jclass BitmapFactoryClass;
75 zoff99 2 jmethodID BitmapFactory_decodeFile, BitmapFactory_decodeResource;
76    
77     jclass BitmapClass;
78     jmethodID Bitmap_getHeight, Bitmap_getWidth;
79    
80     jclass ContextClass;
81     jmethodID Context_getResources;
82    
83     jclass ResourcesClass;
84     jobject Resources;
85     jmethodID Resources_getIdentifier;
86    
87     struct callback_list *cbl;
88     struct window win;
89     };
90    
91 zoff99 27 struct graphics_font_priv
92     {
93 zoff99 2 int size;
94     };
95    
96 zoff99 27 struct graphics_gc_priv
97     {
98 zoff99 2 struct graphics_priv *gra;
99     int linewidth;
100     enum draw_mode_num mode;
101 zoff99 27 int a, r, g, b;
102 zoff99 2 };
103    
104 zoff99 27 struct graphics_image_priv
105     {
106 zoff99 2 jobject Bitmap;
107     int width;
108     int height;
109     struct point hot;
110     };
111    
112     static GHashTable *image_cache_hash = NULL;
113    
114 zoff99 56
115    
116    
117     void drawLineOverlap(uint32_t *map_buffer, int disp_width, int disp_height, int16_t aXStart, int16_t aYStart, int16_t aXEnd, int16_t aYEnd, uint8_t aOverlap,
118     uint32_t aColor, int alpha);
119    
120    
121 zoff99 27 static int find_class_global(char *name, jclass *ret)
122 zoff99 2 {
123 zoff99 30 //DBG // dbg(0,"EEnter\n");
124     JNIEnv *jnienv2;
125     jnienv2 = jni_getenv();
126    
127     *ret = (*jnienv2)->FindClass(jnienv2, name);
128 zoff99 27 if (!*ret)
129     {
130 zoff99 30 //DBG // dbg(0, "Failed to get Class %s\n", name);
131 zoff99 2 return 0;
132     }
133 zoff99 30 *ret = (*jnienv2)->NewGlobalRef(jnienv2, *ret);
134 zoff99 2 return 1;
135     }
136    
137 zoff99 27 static int find_method(jclass class, char *name, char *args, jmethodID *ret)
138 zoff99 2 {
139 zoff99 30 JNIEnv *jnienv2;
140     jnienv2 = jni_getenv();
141    
142     //DBG // dbg(0,"EEnter\n");
143     *ret = (*jnienv2)->GetMethodID(jnienv2, class, name, args);
144 zoff99 27 if (*ret == NULL)
145     {
146 zoff99 30 //DBG // dbg(0, "Failed to get Method %s with signature %s\n", name, args);
147 zoff99 2 return 0;
148     }
149     return 1;
150     }
151    
152 zoff99 27 static int find_static_method(jclass class, char *name, char *args, jmethodID *ret)
153 zoff99 2 {
154 zoff99 30 JNIEnv *jnienv2;
155     jnienv2 = jni_getenv();
156    
157     //DBG // dbg(0,"EEnter\n");
158     *ret = (*jnienv2)->GetStaticMethodID(jnienv2, class, name, args);
159 zoff99 27 if (*ret == NULL)
160     {
161 zoff99 30 //DBG // dbg(0, "Failed to get static Method %s with signature %s\n", name, args);
162 zoff99 2 return 0;
163     }
164     return 1;
165     }
166    
167 zoff99 27 static void graphics_destroy(struct graphics_priv *gr)
168 zoff99 2 {
169     }
170    
171     static void font_destroy(struct graphics_font_priv *font)
172     {
173     g_free(font);
174     }
175    
176 zoff99 27 static struct graphics_font_methods font_methods =
177     { font_destroy };
178 zoff99 2
179 zoff99 27 static struct graphics_font_priv *font_new(struct graphics_priv *gr, struct graphics_font_methods *meth, char *font, int size, int flags)
180 zoff99 2 {
181     struct graphics_font_priv *ret=g_new0(struct graphics_font_priv, 1);
182 zoff99 27 *meth = font_methods;
183 zoff99 2
184 zoff99 27 ret->size = size;
185 zoff99 2 return ret;
186     }
187    
188 zoff99 27 static void gc_destroy(struct graphics_gc_priv *gc)
189 zoff99 2 {
190 zoff99 30 //DBG // dbg(0,"EEnter\n");
191 zoff99 2
192     g_free(gc);
193     }
194    
195 zoff99 27 static void gc_set_linewidth(struct graphics_gc_priv *gc, int w)
196 zoff99 2 {
197 zoff99 27 gc->linewidth = w;
198 zoff99 2 }
199    
200 zoff99 30
201     // UNUSED --------------
202 zoff99 27 static void gc_set_dashes(struct graphics_priv *gra, struct graphics_gc_priv *gc, int w, int offset, int dash_list[], int order)
203 zoff99 2 {
204 zoff99 30 //JNIEnv *jnienv2;
205     //jnienv2 = jni_getenv();
206     //(*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_set_dashes, gc->gra->Paint, dash_list[0], order);
207 zoff99 2 }
208    
209 zoff99 30
210 zoff99 27 static void gc_set_foreground(struct graphics_gc_priv *gc, struct color *c)
211 zoff99 2 {
212 zoff99 27 gc->r = c->r >> 8;
213     gc->g = c->g >> 8;
214     gc->b = c->b >> 8;
215     gc->a = c->a >> 8;
216 zoff99 50
217     // dbg(0, "CCCC:2:%d %d %d %d\n", gc->r, gc->g, gc->b, gc->a);
218 zoff99 2 }
219    
220 zoff99 27 static void gc_set_background(struct graphics_gc_priv *gc, struct color *c)
221 zoff99 2 {
222     }
223    
224 zoff99 27 static struct graphics_gc_methods gc_methods =
225     { gc_destroy, gc_set_linewidth, gc_set_dashes, gc_set_foreground, gc_set_background };
226 zoff99 2
227     static struct graphics_gc_priv *gc_new(struct graphics_priv *gr, struct graphics_gc_methods *meth)
228     {
229 zoff99 30 ////DBG // dbg(0,"EEnter\n");
230 zoff99 2
231     struct graphics_gc_priv *ret=g_new0(struct graphics_gc_priv, 1);
232 zoff99 27 *meth = gc_methods;
233 zoff99 2
234     ret->gra = gr;
235     ret->a = ret->r = ret->g = ret->b = 255;
236 zoff99 27 ret->linewidth = 1;
237 zoff99 2 return ret;
238     }
239    
240     static void image_destroy(struct graphics_image_priv *img)
241     {
242 zoff99 27 // unused?
243 zoff99 2 }
244    
245 zoff99 27 static struct graphics_image_methods image_methods =
246     { image_destroy };
247 zoff99 2
248     static struct graphics_image_priv *
249     image_new(struct graphics_priv *gra, struct graphics_image_methods *meth, char *path, int *w, int *h, struct point *hot, int rotation)
250     {
251 zoff99 30 //DBG // dbg(0,"EEnter\n");
252 zoff99 2
253 zoff99 29 JNIEnv *jnienv2;
254     jnienv2 = jni_getenv();
255    
256 zoff99 30 int thread_id = gettid();
257     // dbg(0, "THREAD ID=%d\n", thread_id);
258    
259    
260 zoff99 2 struct graphics_image_priv* ret = NULL;
261 zoff99 27
262     if (!g_hash_table_lookup_extended(image_cache_hash, path, NULL, (gpointer) & ret))
263 zoff99 2 {
264     ret=g_new0(struct graphics_image_priv, 1);
265     jstring string;
266     int id;
267    
268 zoff99 34 //dbg(0, "enter %s\n", path);
269 zoff99 27 if (!strncmp(path, "res/drawable/", 13))
270     {
271 zoff99 29 jstring a = (*jnienv2)->NewStringUTF(jnienv2, "drawable");
272     jstring b = (*jnienv2)->NewStringUTF(jnienv2, "com.zoffcc.applications.zanavi");
273 zoff99 27 char *path_noext = g_strdup(path + 13);
274     char *pos = strrchr(path_noext, '.');
275     if (pos)
276 zoff99 34 {
277 zoff99 27 *pos = '\0';
278 zoff99 34 }
279     // dbg(0, "path_noext=%s a=%s b=%s\n", path_noext, a, b);
280 zoff99 29 string = (*jnienv2)->NewStringUTF(jnienv2, path_noext);
281 zoff99 2 g_free(path_noext);
282 zoff99 29 id = (*jnienv2)->CallIntMethod(jnienv2, gra->Resources, gra->Resources_getIdentifier, string, a, b);
283 zoff99 30 //DBG // dbg(0, "id=%d\n", id);
284     //DBG // dbg(0,"JNI\n");
285 zoff99 2 if (id)
286 zoff99 27 {
287 zoff99 29 ret->Bitmap = (*jnienv2)->CallStaticObjectMethod(jnienv2, gra->BitmapFactoryClass, gra->BitmapFactory_decodeResource, gra->Resources, id);
288 zoff99 27 }
289 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, b);
290     (*jnienv2)->DeleteLocalRef(jnienv2, a);
291 zoff99 27 }
292     else
293     {
294 zoff99 29 string = (*jnienv2)->NewStringUTF(jnienv2, path);
295 zoff99 30 //DBG // dbg(0,"JNI\n");
296 zoff99 29 ret->Bitmap = (*jnienv2)->CallStaticObjectMethod(jnienv2, gra->BitmapFactoryClass, gra->BitmapFactory_decodeFile, string);
297 zoff99 2 // there should be a check here, if we really want any rotation/scaling
298     // otherwise the call is overkill
299 zoff99 30 //DBG // dbg(0,"JNI\n");
300 zoff99 29 ret->Bitmap = (*jnienv2)->CallStaticObjectMethod(jnienv2, gra->NavitGraphicsClass, gra->NavitGraphicsClass_rotate_and_scale_bitmap, ret->Bitmap, *w, *h, rotation);
301 zoff99 2 }
302 zoff99 52
303 zoff99 27 //// dbg(1, "result=%p\n", ret->Bitmap);
304     if (ret->Bitmap)
305     {
306 zoff99 30 //DBG // dbg(0,"JNI\n");
307 zoff99 29 ret->Bitmap = (*jnienv2)->NewGlobalRef(jnienv2, ret->Bitmap);
308     // ICS (*jnienv2)->DeleteLocalRef(jnienv2, ret->Bitmap);
309 zoff99 30 //DBG // dbg(0,"JNI\n");
310 zoff99 29 ret->width = (*jnienv2)->CallIntMethod(jnienv2, ret->Bitmap, gra->Bitmap_getWidth);
311 zoff99 30 //DBG // dbg(0,"JNI\n");
312 zoff99 29 ret->height = (*jnienv2)->CallIntMethod(jnienv2, ret->Bitmap, gra->Bitmap_getHeight);
313 zoff99 27 //// dbg(1, "w=%d h=%d for %s\n", ret->width, ret->height, path);
314     ret->hot.x = ret->width / 2;
315 zoff99 52
316     // dbg(0, "POI_ICON:001:%s", path);
317    
318     if ( (!strncmp(path, "res/drawable/poi_", 17)) || (!strncmp(path, "poi_", 4)) )
319     {
320     // if icon starts with "poi_" then the hotspot is in the middle of the lower edge
321     ret->hot.y = ret->height;
322     // dbg(0, "POI_ICON:002:%s %d %d", path, ret->hot.y, ret->height);
323     }
324     else
325     {
326     ret->hot.y = ret->height / 2;
327     // dbg(0, "POI_ICON:003:%s %d %d", path, ret->hot.y, ret->height);
328     }
329 zoff99 27 }
330     else
331     {
332 zoff99 2 g_free(ret);
333 zoff99 27 ret = NULL;
334 zoff99 30 //DBG // dbg(0, "Failed to open %s\n", path);
335 zoff99 2 }
336 zoff99 30 //DBG // dbg(0,"JNI\n");
337 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, string);
338 zoff99 30 //DBG // dbg(0,"JNI\n");
339 zoff99 27 g_hash_table_insert(image_cache_hash, g_strdup(path), (gpointer) ret);
340 zoff99 2 }
341 zoff99 34
342 zoff99 27 if (ret)
343     {
344     *w = ret->width;
345     *h = ret->height;
346 zoff99 52
347     // dbg(0, "POI_ICON:004:%s %d %d", path, ret->hot.y, ret->height);
348    
349 zoff99 2 if (hot)
350 zoff99 27 {
351     *hot = ret->hot;
352     }
353 zoff99 2 }
354    
355 zoff99 52 if (ret == NULL)
356     {
357     // log alert: icon missing
358     if (path == NULL)
359     {
360     // ?? no path string ??
361     }
362     else
363     {
364     send_alert_to_java(1, path);
365     }
366     }
367    
368 zoff99 2 return ret;
369     }
370    
371     static void initPaint(struct graphics_priv *gra, struct graphics_gc_priv *gc)
372     {
373 zoff99 30 //DBG // dbg(0,"EEnter\n");
374 zoff99 2
375 zoff99 29 JNIEnv *jnienv2;
376     jnienv2 = jni_getenv();
377    
378 zoff99 27 float wf = gc->linewidth;
379 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gc->gra->Paint, gra->Paint_setStrokeWidth, wf);
380     (*jnienv2)->CallVoidMethod(jnienv2, gc->gra->Paint, gra->Paint_setARGB, gc->a, gc->r, gc->g, gc->b);
381 zoff99 2 }
382    
383 zoff99 27 static void draw_lines(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count)
384 zoff99 2 {
385 zoff99 30 //DBG // dbg(0,"EEnter\n");
386 zoff99 27 jint pc[count * 2];
387 zoff99 2 int i;
388     jintArray points;
389 zoff99 29
390 zoff99 2 if (count <= 0)
391     return;
392 zoff99 29
393     JNIEnv *jnienv2;
394     jnienv2 = jni_getenv();
395    
396     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
397 zoff99 27 for (i = 0; i < count; i++)
398     {
399     pc[i * 2] = p[i].x;
400     pc[i * 2 + 1] = p[i].y;
401 zoff99 2 }
402 zoff99 40 // initPaint(gra, gc);
403 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
404 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline, points, gc->linewidth, gc->r, gc->g, gc->b, gc->a);
405 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, points);
406 zoff99 2 }
407    
408 zoff99 40
409    
410     // for ARGB_888 Bitmap
411     static uint32_t createPixel(int r, int g, int b, int a)
412 zoff99 2 {
413 zoff99 40 if (main_map_bitmapinfo->format == ANDROID_BITMAP_FORMAT_RGBA_8888)
414     {
415     return ((a & 0xff) << 24)
416     | ((b & 0xff) << 16)
417     | ((g & 0xff) << 8)
418     | ((r & 0xff));
419     }
420     else
421     {
422     return 0;
423     }
424     }
425    
426     static int createColorFromPixel_r(uint32_t color)
427     {
428     if (main_map_bitmapinfo->format == ANDROID_BITMAP_FORMAT_RGBA_8888)
429     {
430     return (color & 0xff);
431     }
432     else
433     {
434     return 0;
435     }
436     }
437    
438     static int createColorFromPixel_b(uint32_t color)
439     {
440     if (main_map_bitmapinfo->format == ANDROID_BITMAP_FORMAT_RGBA_8888)
441     {
442     return (color & (0xff << 16));
443     }
444     else
445     {
446     return 0;
447     }
448     }
449    
450     static int createColorFromPixel_g(uint32_t color)
451     {
452     if (main_map_bitmapinfo->format == ANDROID_BITMAP_FORMAT_RGBA_8888)
453     {
454     return (color & (0xff << 8));
455     }
456     else
457     {
458     return 0;
459     }
460     }
461    
462    
463     static void c_set_pixel(uint32_t *map_buffer, int line_width, int height, int x, int y, uint32_t color)
464     {
465     if ((x < 0) || (y < 0) || (x > (line_width -1 )) || (y > (height -1 )))
466     {
467     return;
468     }
469    
470     uint32_t *line = map_buffer;
471     line = line + (y * line_width); // set y-coord
472     ((uint32_t*)line)[x] = color; // x-coord --> set color of pixel
473     }
474    
475     static void c_set_pixel_with_alpha(uint32_t *map_buffer, int line_width, int height, int x, int y, uint32_t color, int alpha)
476     {
477     if ((x < 0) || (y < 0) || (x > (line_width -1 )) || (y > (height -1 )))
478     {
479     return;
480     }
481    
482     uint32_t *line = map_buffer;
483     line = line + (y * line_width); // set y-coord
484     ((uint32_t*)line)[x] = color; // x-coord --> set color of pixel
485     }
486    
487    
488     #define my_lrint(a) ((int)((a)+0.5))
489     #define HYPOT(x,y) sqrtf((x)*(x)+(y)*(y))
490    
491     struct murphy_t
492     {
493     int u,v; /* delta x , delta y */
494     int ku,kt,kv,kd,ks; /* loop constants */
495     int tk;
496     int oct2;
497     int quad4;
498     };
499    
500    
501     inline float normconstant(float fu, float fv)
502     {
503     const int choice=2; /*change this to suit taste/compute power etc.*/
504     const int u=fabs(fu), v=fabs(fv);
505    
506     switch (choice)
507     {
508     case 1:
509     return (u+v>>2); /*12% thickness error - uses add and shift only*/
510     case 2:
511     if ((v+v+v)>u) /*2.7% thickness error, uses compare, add and shift only*/
512     {
513     return (u-(u>>3)+(v>>1));
514     }
515     else
516     {
517     return (u+(v>>3));
518     }
519     case 3:
520     return HYPOT(u,v); /*ideal*/
521     }
522    
523     return 0;
524     }
525    
526    
527     static void murphy_perpendicular(struct murphy_t *murphy, int pt_x, int pt_y, int d0, int d1, uint32_t color, uint32_t *map_buffer, int line_width, int height)
528     { /*Implements Figure 4B*/
529    
530     d0=-d0;
531     int q;
532    
533     // dbg(0,"enter:bitmap:001 tk=%d d0=%d kt=%d kd=%d ku=%d kv=%d ks=%d\n", murphy->tk, d0, murphy->kt, murphy->kd, murphy->ku, murphy->kv, murphy->ks);
534    
535     //if ((d0 == 0) && (murphy->tk == 0))
536     //{
537     // return;
538     //}
539    
540     for(q=0; d0 <= murphy->tk; ++q )
541     { /*inner loop counter*/
542     //dbg(0,"bitmap:003.1 tk=%d q=%d d0=%d\n", murphy->tk, q, d0);
543    
544     c_set_pixel(map_buffer, line_width, height, pt_x, pt_y, color);
545    
546     if (d1 < murphy->kt)
547     { /*square move MS*/
548     // OO // ++pt_y;
549     ++pt_y;
550     d1+=murphy->kv;
551     d0+=murphy->ku;
552     }
553     else
554     { /*diagonal move MD*/
555     // OO // --pt_x;
556     // OO // ++pt_y;
557     --pt_x;
558     ++pt_y;
559     d1+=murphy->kd;
560     d0+=murphy->ks;
561     }
562    
563     if (q > 10000)
564     {
565     dbg(0,"enter:bitmap:001 tk=%d d0=%d kt=%d kd=%d ku=%d kv=%d ks=%d\n", murphy->tk, d0, murphy->kt, murphy->kd, murphy->ku, murphy->kv, murphy->ks);
566     dbg(0,"bitmap:003.1 tk=%d q=%d d0=%d\n", murphy->tk, q, d0);
567    
568     dbg(0, "bitmap:**ERROR** in loop!! \n");
569     break;
570     }
571    
572     //dbg(0,"bitmap:003.2\n");
573     }
574    
575     //dbg(0,"bitmap:ready:099\n");
576     }
577    
578    
579     static void murphy_wideline(uint32_t *map_buffer, int line_width, int height, int from_x, int from_y, int to_x, int to_y, uint32_t color, int width)
580     {
581     struct murphy_t murphy;
582     int pt_x, pt_y;
583     int temp;
584    
585     int orig_dx;
586     int orig_dy;
587     int steep;
588     int quart;
589    
590     float offset = width / 2.0f;
591    
592     murphy.u = to_x - from_x; /*delta x*/
593     murphy.v = to_y - from_y; /*delta y*/
594    
595     orig_dx = murphy.u;
596     orig_dy = murphy.v;
597    
598     steep = 0;
599     if (abs(orig_dy) > abs(orig_dx))
600     {
601     steep = 1;
602     }
603    
604     if (orig_dy < 0) // oben
605     {
606     if (orig_dx < 0) // links
607     {
608     quart = 2;
609     }
610     else // rechts
611     {
612     quart = 1;
613     }
614     }
615     else // unten
616     {
617     if (orig_dx < 0) // links
618     {
619     quart = 3;
620     }
621     else // rechts
622     {
623     quart = 4;
624     }
625     }
626    
627     dbg(0,"enter:bitmap:001.0 dx=%d dy=%d steep=%d quart=%d\n", orig_dx, orig_dy, steep, quart);
628    
629    
630     if (murphy.u < 0) /* delta x < 0 --> links */
631     { /* swap to make sure we are in quadrants 1 or 4 --> turn 180° to left */
632     temp = to_x;
633     to_x = from_x;
634     from_x = temp;
635    
636     temp = to_y;
637     to_y = from_y;
638     from_y = temp;
639    
640     murphy.u *= -1;
641     murphy.v *= -1;
642     }
643    
644     if (murphy.v < 0) /* delta y < 0 --> rechts oben */
645     { /* swap to 1st quadrant and flag */
646     murphy.v *= -1; // *(-1)
647     murphy.quad4 = 1; // 1
648     }
649     else // rechts unten
650     {
651     // murphy.v *= -1; // ----
652     murphy.quad4 = 0; // 0
653     }
654    
655     if (murphy.v > murphy.u) // steile linie (v > u)
656     {
657     /* deltay > deltax = octant 2
658     /* swap things if in 2 octant */
659     temp = murphy.u;
660     murphy.u = murphy.v;
661     murphy.v = temp;
662    
663     murphy.oct2 = 1; // 1
664     }
665     else // flache linie
666     {
667     murphy.oct2 = 0; // 0
668     }
669    
670     //if ( (steep == 0)&&( (quart==1)||(quart==3) ) )
671     //{
672     // murphy.ku=murphy.u+murphy.u; // 2*dx /*change in l for square shift*/
673     // murphy.kv=-murphy.v-murphy.v; // 2*dy /*change in d for square shift*/
674     // murphy.kd=murphy.kv-murphy.ku; // 2*dy - 2*dx /*change in d for diagonal shift*/
675     // murphy.ks=murphy.kv+murphy.ku; // 2*dy + 2*dx /*change in l for diagonal shift*/
676     // murphy.kt=murphy.u-murphy.kv; // dx - (2*dy) /*diag/square decision threshold*/
677     //}
678     //else
679     //{
680     murphy.ku=murphy.u+murphy.u; // 2*dx /*change in l for square shift*/
681     murphy.kv=murphy.v+murphy.v; // 2*dy /*change in d for square shift*/
682     murphy.kd=murphy.kv-murphy.ku; // 2*dy - 2*dx /*change in d for diagonal shift*/
683    
684     murphy.ks=murphy.kv+murphy.ku; // 2*dy + 2*dx /*change in l for diagonal shift*/
685     murphy.kt=murphy.u-murphy.kv; // dx - (2*dy) /*diag/square decision threshold*/
686     //}
687    
688     dbg(0,"enter:bitmap:001a.1 x1=%d y1=%d x2=%d y2=%d\n", from_x, from_y, to_x, to_y);
689     dbg(0,"enter:bitmap:001a.2 u=%d v=%d o2=%d q4=%d\n", murphy.u, murphy.v, murphy.oct2, murphy.quad4);
690     dbg(0,"enter:bitmap:001a.4 ku=%d kv=%d kd=%d ks=%d kt=%d\n", murphy.ku, murphy.kv, murphy.kd, murphy.ks, murphy.kt);
691    
692     int d0 = 0,d1 = 0;
693     float ang;
694    
695     if (murphy.v == 0)
696     {
697     ang = 0.0f;
698     dbg(0,"bitmap:003c ang=%f v=%d\n", ang, murphy.v);
699     }
700     else if (murphy.u == 0)
701     {
702     //ang = atanf((float)murphy.v/(float)murphy.u); /* calc new initial point - offset both sides of ideal */
703     ang = 3.1415f / 2.0f;
704     dbg(0,"bitmap:003a ang=%f v=%d\n", ang, murphy.v);
705     }
706     else
707     {
708     errno = 0;
709     ang = atanf((float)murphy.v/(float)murphy.u); /* calc new initial point - offset both sides of ideal */
710     dbg(0,"bitmap:003b ang=%f errno=%d\n", ang, errno);
711    
712     if (errno != 0)
713     {
714     ang = 0.0f;
715     }
716     }
717    
718     if (murphy.oct2 == 0) // ==
719     {
720     pt_x = from_x + my_lrint(offset * sinf(ang)); // sinf +
721     if (murphy.quad4 == 0) // ==
722     {
723     pt_y = from_y - my_lrint(offset * cosf(ang)); // cosf -
724     }
725     else
726     {
727     pt_y = from_y + my_lrint(offset * cosf(ang)); // cosf +
728     }
729     }
730     else
731     {
732     pt_x = from_x + my_lrint(offset * cosf(ang)); // cosf +
733     if (murphy.quad4 == 0) // ==
734     {
735     pt_y = from_y + my_lrint(offset * sinf(ang)); // sinf +
736     }
737     else
738     {
739     pt_y = from_y - my_lrint(offset * sinf(ang)); // sinf -
740     }
741     }
742    
743     dbg(0,"enter:bitmap:001c fx=%d fy=%d xmiddle=%d ymiddle=%d\n", from_x, from_y, pt_x, pt_y);
744    
745     //dbg(0,"bitmap:004\n");
746     murphy.tk = 4.*HYPOT(pt_x-from_x, pt_y-from_y) * normconstant(murphy.u,murphy.v); /*used here for constant thickness line*/
747     dbg(0,"bitmap:005 tk=%d\n", murphy.tk);
748    
749    
750     int p=0;
751     /*outer loop counter*/
752    
753     while (p <= murphy.u) // run from [ 0 .. delta x ]
754     {
755     /*outer loop, stepping along line*/
756    
757     dbg(0,"bitmap:006.1 p=%d m.u=%d pt_x=%d pt_y=%d d0=%d d1=%d\n", p, murphy.u, pt_x, pt_y, d0, d1);
758     // ** murphy_perpendicular(&murphy, pt_x, pt_y, d0, d1, color, map_buffer, line_width, height);
759     dbg(0,"bitmap:006.1 p=%d m.u=%d pt_x=%d pt_y=%d d0=%d d1=%d\n", p, murphy.u, pt_x, pt_y, d0, d1);
760     c_set_pixel(map_buffer, line_width, height, pt_x, pt_y, color);
761     //dbg(0,"bitmap:006.2\n");
762    
763     if (1 == 1) // (d0 < murphy.kt)
764     {
765     /*square move*/
766     if (murphy.oct2 == 0) // ==
767     {
768     if (murphy.quad4 == 0) // ==
769     {
770     // OO // ++pt_y;
771     ++pt_y;
772     }
773     else
774     {
775     // OO // --pt_y;
776     --pt_y;
777     }
778     }
779     else
780     {
781     // OO // ++pt_x;
782     ++pt_x;
783     }
784     }
785     else
786     {
787     /*diagonal move*/
788     d0 -= murphy.ku;
789     if (d1 < murphy.kt)
790     {
791     /*normal start*/
792     ++pt_x;
793     ++pt_y; /*move M1*/
794     d1 += murphy.kv;
795     }
796     else
797     {
798     /*double square move, need extra perpendicular line*/
799     ++pt_y; /*move M2*/
800     d1 += murphy.kd;
801     dbg(0,"bitmap:006.2 p=%d m.u=%d pt_x=%d pt_y=%d d0=%d d1=%d\n", p, murphy.u, pt_x, pt_y, d0, d1);
802     // ** murphy_perpendicular(&murphy,pt_x,pt_y,d0,d1, color, map_buffer, line_width, height); /*extra perpendicular*/
803     dbg(0,"bitmap:006.2 p=%d m.u=%d pt_x=%d pt_y=%d d0=%d d1=%d\n", p, murphy.u, pt_x, pt_y, d0, d1);
804     c_set_pixel(map_buffer, line_width, height, pt_x, pt_y, color);
805     ++pt_x; /*move m0*/
806     }
807     }
808    
809     d0 += murphy.kv;
810     ++p;
811    
812     //dbg(0,"bitmap:006.99\n");
813     }
814    
815     //dbg(0,"bitmap:ready:99\n");
816     }
817    
818    
819    
820    
821    
822    
823    
824     /**************************************************************************
825     * *
826     * draws a line using Bresenham's line-drawing algorithm, which uses *
827     * no multiplication or division. *
828     **************************************************************************/
829    
830     #define sgn(x) ((x<0)?-1:((x>0)?1:0)) /* macro to return the sign of a
831     number */
832    
833     static void c_draw_line3_fast(uint32_t *map_buffer, int line_width, int height, int x1, int y1, int x2, int y2, uint32_t color)
834     {
835     //uint32_t color = createPixel(r, g, b, a);
836    
837     //dbg(0, "bitmap line:%d %d %d %d\n", x1, y1, x2, y2);
838    
839     int i,dx,dy,sdx,sdy,dxabs,dyabs,x,y,px,py;
840    
841     dx=x2-x1; /* the horizontal distance of the line */
842     dy=y2-y1; /* the vertical distance of the line */
843     dxabs=abs(dx);
844     dyabs=abs(dy);
845     sdx=sgn(dx);
846     sdy=sgn(dy);
847     x=dyabs >> 1;
848     y=dxabs >> 1;
849     px=x1;
850     py=y1;
851    
852     if (dxabs>=dyabs) // the line is more horizontal than vertical
853     {
854     for(i=0;i < dxabs;i++)
855     {
856     y+=dyabs;
857     if (y >= dxabs)
858     {
859     y-=dxabs;
860     py+=sdy;
861     }
862     px+=sdx;
863    
864     c_set_pixel(map_buffer, line_width, height, px, py, color);
865     }
866     }
867     else // the line is more vertical than horizontal
868     {
869     for(i=0;i < dyabs;i++)
870     {
871     x+=dxabs;
872     if (x >= dyabs)
873     {
874     x-=dyabs;
875     px+=sdx;
876     }
877     py+=sdy;
878    
879     c_set_pixel(map_buffer, line_width, height, px, py, color);
880     }
881     }
882     }
883    
884    
885    
886    
887    
888    
889    
890    
891    
892    
893    
894    
895    
896    
897    
898    
899     // -------------------
900     // -------------------
901     // -------------------
902     // -------------------
903     // -------------------
904     // -------------------
905     // -------------------
906     // -------------------
907     // -------------------
908     // -------------------
909     // -------------------
910     // -------------------
911     // -------------------
912     // -------------------
913     // -------------------
914     // -------------------
915     // -------------------
916     // -------------------
917     // -------------------
918     // -------------------
919     // -------------------
920     // -------------------
921     // -------------------
922     // -------------------
923     // -------------------
924     // -------------------
925     // -------------------
926     // -------------------
927     // -------------------
928     // -------------------
929     // -------------------
930     // -------------------
931    
932     #define LINE_OVERLAP_NONE 0 // No line overlap
933     #define LINE_OVERLAP_MAJOR 0x01 // Overlap - first go major then minor direction
934     #define LINE_OVERLAP_MINOR 0x02 // Overlap - first go minor then major direction
935     #define LINE_OVERLAP_BOTH 0x03 // Overlap - both
936    
937     #define LINE_THICKNESS_MIDDLE 0
938     #define LINE_THICKNESS_DRAW_CLOCKWISE 1
939     #define LINE_THICKNESS_DRAW_COUNTERCLOCKWISE 2
940    
941     struct ThickLine
942     {
943     int16_t StartX;
944     int16_t StartY;
945     int16_t EndX;
946     int16_t EndY;
947     int16_t Thickness;
948     uint8_t ThicknessMode;
949     uint32_t Color;
950     uint32_t BackgroundColor;
951     };
952    
953     typedef int bool;
954     #define true 1
955     #define false 0
956    
957    
958     static void c_set_pixel2(uint32_t *map_buffer, int line_width, int height, uint16_t x, uint16_t y, uint32_t color)
959     {
960     if ((x < 0) || (y < 0) || (x > (line_width -1 )) || (y > (height -1)))
961     {
962     return;
963     }
964    
965     uint32_t *line = map_buffer;
966     line = line + (y * line_width); // set y-coord
967     ((uint32_t*)line)[x] = color; // x-coord --> set color of pixel
968     }
969    
970     static void c_set_pixel2_with_alpha(uint32_t *map_buffer, int line_width, int height, uint16_t x, uint16_t y, uint32_t color, int alpha)
971     {
972     if ((x < 0) || (y < 0) || (x > (line_width -1 )) || (y > (height -1)))
973     {
974     return;
975     }
976    
977     // alpha 0 -> transparent
978     // alpha 255 -> full line
979    
980     if (alpha == 0)
981     {
982     return;
983     }
984    
985     // alpha2 = float [0 .. 1]
986     float alpha2 = (float)alpha / 255.0f;
987     float one_minus_alpha2 = 1 - alpha2;
988    
989     uint32_t *line = map_buffer;
990     line = line + (y * line_width); // set y-coord
991    
992     uint32_t color_old = ((uint32_t*)line)[x];
993    
994     // formula: out = alpha2 * new + (1 - alpha2) * old
995     int r_out = alpha2 * (float)createColorFromPixel_r(color) + one_minus_alpha2 * (float)createColorFromPixel_r(color_old);
996     int g_out = alpha2 * (float)createColorFromPixel_g(color) + one_minus_alpha2 * (float)createColorFromPixel_g(color_old);
997     int b_out = alpha2 * (float)createColorFromPixel_b(color) + one_minus_alpha2 * (float)createColorFromPixel_b(color_old);
998     if (r_out > 255)
999     {
1000     r_out = 255;
1001     }
1002     if (g_out > 255)
1003     {
1004     g_out = 255;
1005     }
1006     if (b_out > 255)
1007     {
1008     b_out = 255;
1009     }
1010    
1011     uint32_t color_out = createPixel(r_out, g_out, b_out, 255);
1012    
1013     ((uint32_t*)line)[x] = color_out; // x-coord --> set color of pixel
1014     }
1015    
1016    
1017     #if 0
1018     static void c_fillRect(uint32_t *map_buffer, int line_width, int height, int16_t aXStart, int16_t aYStart, int16_t aXEnd, int16_t aYEnd, uint32_t aColor)
1019     {
1020     dbg(0, "enter\n");
1021    
1022     return;
1023    
1024     int i;
1025     int j;
1026     int16_t temp;
1027     uint32_t *line = map_buffer;
1028    
1029     if (aYEnd < aYStart)
1030     {
1031     temp = aYStart;
1032     aYStart = aYEnd;
1033     aYEnd = temp;
1034     }
1035    
1036     if (aXEnd < aXStart)
1037     {
1038     temp = aXStart;
1039     aXStart = aXEnd;
1040     aXEnd = temp;
1041     }
1042    
1043     line = line + (aYStart * line_width); // set y-coord
1044     for(j = aYStart;j <= aYEnd;j++)
1045     {
1046     if ((j >= 0)||(j < height))
1047     {
1048     for(i = aXStart;i <= aXEnd;aXStart++)
1049     {
1050     if ((i >= 0)||(i < line_width))
1051     {
1052     ((uint32_t*)line)[i] = aColor; // x-coord --> set color of pixel
1053     }
1054     }
1055     }
1056     line++;
1057     }
1058    
1059     dbg(0, "leave\n");
1060     }
1061     #endif
1062    
1063    
1064     /**
1065     * modified Bresenham
1066     */
1067     void drawLine(uint32_t *map_buffer, int disp_width, int disp_height, uint16_t aXStart, uint16_t aYStart, uint16_t aXEnd, uint16_t aYEnd, uint32_t aColor, int alpha)
1068     {
1069     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, LINE_OVERLAP_NONE, aColor, alpha);
1070     }
1071    
1072     /**
1073     * modified Bresenham with optional overlap (esp. for drawThickLine())
1074     * Overlap draws additional pixel when changing minor direction - for standard bresenham overlap = LINE_OVERLAP_NONE (0)
1075     *
1076     * Sample line:
1077     *
1078     * 00+
1079     * -0000+
1080     * -0000+
1081     * -00
1082     *
1083     * 0 pixels are drawn for normal line without any overlap
1084     * + pixels are drawn if LINE_OVERLAP_MAJOR
1085     * - pixels are drawn if LINE_OVERLAP_MINOR
1086     */
1087    
1088    
1089     void drawLineOverlap(uint32_t *map_buffer, int disp_width, int disp_height, int16_t aXStart, int16_t aYStart, int16_t aXEnd, int16_t aYEnd, uint8_t aOverlap,
1090     uint32_t aColor, int alpha)
1091     {
1092    
1093     //dbg(0, " enter\n");
1094    
1095     int16_t tDeltaX, tDeltaY, tDeltaXTimes2, tDeltaYTimes2, tError, tStepX, tStepY;
1096    
1097     /*
1098     if (aXStart >= disp_width) {
1099     aXStart = disp_width - 1;
1100     }
1101     if (aXStart < 0) {
1102     aXStart = 0;
1103     }
1104     if (aXEnd >= disp_width) {
1105     aXEnd = disp_width - 1;
1106     }
1107     if (aXEnd < 0) {
1108     aXEnd = 0;
1109     }
1110     if (aYStart >= disp_height) {
1111     aYStart = disp_height - 1;
1112     }
1113     if (aYStart < 0) {
1114     aYStart = 0;
1115     }
1116     if (aYEnd >= disp_height) {
1117     aYEnd = disp_height - 1;
1118     }
1119     if (aYEnd < 0) {
1120     aYEnd = 0;
1121     }
1122     */
1123    
1124     //if (aXStart == aXEnd)
1125     //{
1126     // //horizontal or vertical line -> fillRect() is faster
1127     // // fillRect(aXStart, aYStart, aXEnd, aYEnd, aColor);
1128     // //c_fillRect(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, aColor);
1129     //}
1130     //else
1131     //{
1132     //calculate direction
1133     tDeltaX = aXEnd - aXStart;
1134     tDeltaY = aYEnd - aYStart;
1135     if (tDeltaX < 0) {
1136     tDeltaX = -tDeltaX;
1137     tStepX = -1;
1138     } else {
1139     tStepX = +1;
1140     }
1141     if (tDeltaY < 0) {
1142     tDeltaY = -tDeltaY;
1143     tStepY = -1;
1144     } else {
1145     tStepY = +1;
1146     }
1147     tDeltaXTimes2 = tDeltaX << 1;
1148     tDeltaYTimes2 = tDeltaY << 1;
1149     //draw start pixel
1150     if (alpha != 255)
1151     {
1152     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1153     }
1154     else
1155     {
1156     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor);
1157     }
1158     // drawPixel(aXStart, aYStart, aColor);
1159     if (tDeltaX > tDeltaY)
1160     {
1161     // start value represents a half step in Y direction
1162     tError = tDeltaYTimes2 - tDeltaX;
1163     //dbg(0, " w loop1 start\n");
1164     while (aXStart != aXEnd)
1165     {
1166     // step in main direction
1167     aXStart += tStepX;
1168     if (tError >= 0)
1169     {
1170     if (aOverlap & LINE_OVERLAP_MAJOR)
1171     {
1172     // draw pixel in main direction before changing
1173     if (alpha != 255)
1174     {
1175     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1176     }
1177     else
1178     {
1179     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor);
1180     }
1181     // drawPixel(aXStart, aYStart, aColor);
1182     }
1183     // change Y
1184     aYStart += tStepY;
1185     if (aOverlap & LINE_OVERLAP_MINOR)
1186     {
1187     // draw pixel in minor direction before changing
1188     if (alpha != 255)
1189     {
1190     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1191     }
1192     else
1193     {
1194     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart - tStepX, aYStart, aColor);
1195     }
1196     // drawPixel(aXStart - tStepX, aYStart, aColor);
1197     }
1198     tError -= tDeltaXTimes2;
1199     }
1200     tError += tDeltaYTimes2;
1201     if (alpha != 255)
1202     {
1203     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1204     }
1205     else
1206     {
1207     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor);
1208     }
1209     // drawPixel(aXStart, aYStart, aColor);
1210     }
1211     //dbg(0, " w loop1 end\n");
1212     }
1213     else
1214     {
1215     tError = tDeltaXTimes2 - tDeltaY;
1216     //dbg(0, " w loop2 start\n");
1217     while (aYStart != aYEnd)
1218     {
1219     aYStart += tStepY;
1220     if (tError >= 0) {
1221     if (aOverlap & LINE_OVERLAP_MAJOR) {
1222     // draw pixel in main direction before changing
1223     if (alpha != 255)
1224     {
1225     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1226     }
1227     else
1228     {
1229     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor);
1230     }
1231     // drawPixel(aXStart, aYStart, aColor);
1232     }
1233     aXStart += tStepX;
1234     if (aOverlap & LINE_OVERLAP_MINOR) {
1235     // draw pixel in minor direction before changing
1236     if (alpha != 255)
1237     {
1238     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1239     }
1240     else
1241     {
1242     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart - tStepY, aColor);
1243     }
1244     // drawPixel(aXStart, aYStart - tStepY, aColor);
1245     }
1246     tError -= tDeltaYTimes2;
1247     }
1248     tError += tDeltaXTimes2;
1249     if (alpha != 255)
1250     {
1251     c_set_pixel2_with_alpha(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor, alpha);
1252     }
1253     else
1254     {
1255     c_set_pixel2(map_buffer, disp_width, disp_height, aXStart, aYStart, aColor);
1256     }
1257     // drawPixel(aXStart, aYStart, aColor);
1258     }
1259     //dbg(0, " w loop2 end\n");
1260     }
1261     //}
1262    
1263     //dbg(0, " leave\n");
1264     }
1265    
1266    
1267    
1268     /**
1269     * Bresenham with thickness
1270     * no pixel missed and every pixel only drawn once!
1271     */
1272     void drawThickLine(uint32_t *map_buffer, int disp_width, int disp_height, int16_t aXStart, int16_t aYStart, int16_t aXEnd, int16_t aYEnd, int16_t aThickness, uint8_t aThicknessMode,
1273     uint32_t aColor, int alpha)
1274     {
1275     int16_t i, tDeltaX, tDeltaY, tDeltaXTimes2, tDeltaYTimes2, tError, tStepX, tStepY;
1276    
1277     if(aThickness <= 1)
1278     {
1279     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, LINE_OVERLAP_NONE, aColor, alpha);
1280     return;
1281     }
1282    
1283     /*
1284     if (aXStart >= disp_width) {
1285     aXStart = disp_width - 1;
1286     }
1287     if (aXStart < 0) {
1288     aXStart = 0;
1289     }
1290     if (aXEnd >= disp_width) {
1291     aXEnd = disp_width - 1;
1292     }
1293     if (aXEnd < 0) {
1294     aXEnd = 0;
1295     }
1296     if (aYStart >= disp_height) {
1297     aYStart = disp_height - 1;
1298     }
1299     if (aYStart < 0) {
1300     aYStart = 0;
1301     }
1302     if (aYEnd >= disp_height) {
1303     aYEnd = disp_height - 1;
1304     }
1305     if (aYEnd < 0) {
1306     aYEnd = 0;
1307     }
1308     */
1309    
1310     /**
1311     * For coordinatesystem with 0.0 topleft
1312     * Swap X and Y delta and calculate clockwise (new delta X inverted)
1313     * or counterclockwise (new delta Y inverted) rectangular direction.
1314     * The right rectangular direction for LINE_OVERLAP_MAJOR toggles with each octant
1315     */
1316     tDeltaY = aXEnd - aXStart;
1317     tDeltaX = aYEnd - aYStart;
1318     // mirror 4 quadrants to one and adjust deltas and stepping direction
1319     bool tSwap = true; // count effective mirroring
1320     if (tDeltaX < 0) {
1321     tDeltaX = -tDeltaX;
1322     tStepX = -1;
1323     tSwap = !tSwap;
1324     } else {
1325     tStepX = +1;
1326     }
1327     if (tDeltaY < 0) {
1328     tDeltaY = -tDeltaY;
1329     tStepY = -1;
1330     tSwap = !tSwap;
1331     } else {
1332     tStepY = +1;
1333     }
1334     tDeltaXTimes2 = tDeltaX << 1;
1335     tDeltaYTimes2 = tDeltaY << 1;
1336     bool tOverlap;
1337    
1338     // adjust for right direction of thickness from line origin
1339     int tDrawStartAdjustCount = aThickness / 2;
1340     if (aThicknessMode == LINE_THICKNESS_DRAW_COUNTERCLOCKWISE)
1341     {
1342     tDrawStartAdjustCount = aThickness - 1;
1343     }
1344     else if (aThicknessMode == LINE_THICKNESS_DRAW_CLOCKWISE)
1345     {
1346     tDrawStartAdjustCount = 0;
1347     }
1348    
1349     // which octant are we now
1350     if (tDeltaX >= tDeltaY) {
1351     if (tSwap) {
1352     tDrawStartAdjustCount = (aThickness - 1) - tDrawStartAdjustCount;
1353     tStepY = -tStepY;
1354     } else {
1355     tStepX = -tStepX;
1356     }
1357     /*
1358     * Vector for draw direction of lines is rectangular and counterclockwise to original line
1359     * Therefore no pixel will be missed if LINE_OVERLAP_MAJOR is used
1360     * on changing in minor rectangular direction
1361     */
1362     // adjust draw start point
1363     tError = tDeltaYTimes2 - tDeltaX;
1364     for (i = tDrawStartAdjustCount; i > 0; i--) {
1365     // change X (main direction here)
1366     aXStart -= tStepX;
1367     aXEnd -= tStepX;
1368     if (tError >= 0) {
1369     // change Y
1370     aYStart -= tStepY;
1371     aYEnd -= tStepY;
1372     tError -= tDeltaXTimes2;
1373     }
1374     tError += tDeltaYTimes2;
1375     }
1376     //draw start line
1377     drawLine(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, aColor, alpha);
1378     // draw aThickness lines
1379     tError = tDeltaYTimes2 - tDeltaX;
1380     for (i = aThickness; i > 1; i--) {
1381     // change X (main direction here)
1382     aXStart += tStepX;
1383     aXEnd += tStepX;
1384     tOverlap = LINE_OVERLAP_NONE;
1385     if (tError >= 0) {
1386     // change Y
1387     aYStart += tStepY;
1388     aYEnd += tStepY;
1389     tError -= tDeltaXTimes2;
1390     /*
1391     * change in minor direction reverse to line (main) direction
1392     * because of chosing the right (counter)clockwise draw vector
1393     * use LINE_OVERLAP_MAJOR to fill all pixel
1394     *
1395     * EXAMPLE:
1396     * 1,2 = Pixel of first lines
1397     * 3 = Pixel of third line in normal line mode
1398     * - = Pixel which will be drawn in LINE_OVERLAP_MAJOR mode
1399     * 33
1400     * 3333-22
1401     * 3333-222211
1402     * 33-22221111
1403     * 221111 /\
1404     * 11 Main direction of draw vector
1405     * -> Line main direction
1406     * <- Minor direction of counterclockwise draw vector
1407     */
1408     tOverlap = LINE_OVERLAP_MAJOR;
1409     }
1410     tError += tDeltaYTimes2;
1411     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor, alpha);
1412     }
1413     } else {
1414     // the other octant
1415     if (tSwap) {
1416     tStepX = -tStepX;
1417     } else {
1418     tDrawStartAdjustCount = (aThickness - 1) - tDrawStartAdjustCount;
1419     tStepY = -tStepY;
1420     }
1421     // adjust draw start point
1422     tError = tDeltaXTimes2 - tDeltaY;
1423     for (i = tDrawStartAdjustCount; i > 0; i--) {
1424     aYStart -= tStepY;
1425     aYEnd -= tStepY;
1426     if (tError >= 0) {
1427     aXStart -= tStepX;
1428     aXEnd -= tStepX;
1429     tError -= tDeltaYTimes2;
1430     }
1431     tError += tDeltaXTimes2;
1432     }
1433     //draw start line
1434     drawLine(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, aColor, alpha);
1435     tError = tDeltaXTimes2 - tDeltaY;
1436     for (i = aThickness; i > 1; i--) {
1437     aYStart += tStepY;
1438     aYEnd += tStepY;
1439     tOverlap = LINE_OVERLAP_NONE;
1440     if (tError >= 0) {
1441     aXStart += tStepX;
1442     aXEnd += tStepX;
1443     tError -= tDeltaYTimes2;
1444     tOverlap = LINE_OVERLAP_MAJOR;
1445     }
1446     tError += tDeltaXTimes2;
1447     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor, alpha);
1448     }
1449     }
1450     }
1451    
1452    
1453    
1454     /**
1455     * The same as before, but no clipping, some pixel are drawn twice (use LINE_OVERLAP_BOTH)
1456     * and direction of thickness changes for each octant (except for LINE_THICKNESS_MIDDLE and aThickness odd)
1457     */
1458     void drawThickLineSimple(uint32_t *map_buffer, int disp_width, int disp_height, int16_t aXStart, int16_t aYStart, int16_t aXEnd, int16_t aYEnd, int16_t aThickness,
1459     uint8_t aThicknessMode, uint32_t aColor, int alpha)
1460     {
1461     //dbg(0, "enter\n");
1462    
1463     if(aThickness <= 1)
1464     {
1465     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, LINE_OVERLAP_NONE, aColor, alpha);
1466     //dbg(0, "return 001\n");
1467     return;
1468     }
1469    
1470    
1471     int16_t i, tDeltaX, tDeltaY, tDeltaXTimes2, tDeltaYTimes2, tError, tStepX, tStepY;
1472    
1473     tDeltaY = aXStart - aXEnd;
1474     tDeltaX = aYEnd - aYStart;
1475     // mirror 4 quadrants to one and adjust deltas and stepping direction
1476     if (tDeltaX < 0) {
1477     tDeltaX = -tDeltaX;
1478     tStepX = -1;
1479     } else {
1480     tStepX = +1;
1481     }
1482     if (tDeltaY < 0) {
1483     tDeltaY = -tDeltaY;
1484     tStepY = -1;
1485     } else {
1486     tStepY = +1;
1487     }
1488     tDeltaXTimes2 = tDeltaX << 1;
1489     tDeltaYTimes2 = tDeltaY << 1;
1490     bool tOverlap;
1491     // which octant are we now
1492     if (tDeltaX > tDeltaY)
1493     {
1494     if (aThicknessMode == LINE_THICKNESS_MIDDLE)
1495     {
1496     // adjust draw start point
1497     tError = tDeltaYTimes2 - tDeltaX;
1498     for (i = aThickness / 2; i > 0; i--)
1499     {
1500     // change X (main direction here)
1501     aXStart -= tStepX;
1502     aXEnd -= tStepX;
1503     if (tError >= 0)
1504     {
1505     // change Y
1506     aYStart -= tStepY;
1507     aYEnd -= tStepY;
1508     tError -= tDeltaXTimes2;
1509     }
1510     tError += tDeltaYTimes2;
1511     }
1512     }
1513     //draw start line
1514     //drawLine(aXStart, aYStart, aXEnd, aYEnd, aColor);
1515     drawLine(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, aColor, alpha);
1516     // draw aThickness lines
1517     tError = tDeltaYTimes2 - tDeltaX;
1518    
1519     for (i = aThickness; i > 1; i--)
1520     {
1521     // change X (main direction here)
1522     aXStart += tStepX;
1523     aXEnd += tStepX;
1524     tOverlap = LINE_OVERLAP_NONE;
1525     if (tError >= 0)
1526     {
1527     // change Y
1528     aYStart += tStepY;
1529     aYEnd += tStepY;
1530     tError -= tDeltaXTimes2;
1531     tOverlap = LINE_OVERLAP_BOTH;
1532     }
1533     tError += tDeltaYTimes2;
1534     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor, alpha);
1535     // drawLineOverlap(aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor);
1536     }
1537     }
1538     else
1539     {
1540     // adjust draw start point
1541     if (aThicknessMode == LINE_THICKNESS_MIDDLE)
1542     {
1543     tError = tDeltaXTimes2 - tDeltaY;
1544     for (i = aThickness / 2; i > 0; i--)
1545     {
1546     aYStart -= tStepY;
1547     aYEnd -= tStepY;
1548     if (tError >= 0)
1549     {
1550     aXStart -= tStepX;
1551     aXEnd -= tStepX;
1552     tError -= tDeltaYTimes2;
1553     }
1554     tError += tDeltaXTimes2;
1555     }
1556     }
1557     //draw start line
1558     //drawLine(aXStart, aYStart, aXEnd, aYEnd, aColor);
1559     drawLine(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, aColor, alpha);
1560     tError = tDeltaXTimes2 - tDeltaY;
1561     for (i = aThickness; i > 1; i--)
1562     {
1563     aYStart += tStepY;
1564     aYEnd += tStepY;
1565     tOverlap = LINE_OVERLAP_NONE;
1566     if (tError >= 0)
1567     {
1568     aXStart += tStepX;
1569     aXEnd += tStepX;
1570     tError -= tDeltaYTimes2;
1571     tOverlap = LINE_OVERLAP_BOTH;
1572     }
1573     tError += tDeltaXTimes2;
1574     drawLineOverlap(map_buffer, disp_width, disp_height, aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor, alpha);
1575     // drawLineOverlap(aXStart, aYStart, aXEnd, aYEnd, tOverlap, aColor);
1576     }
1577     }
1578    
1579     //dbg(0, "leave\n");
1580    
1581     }
1582    
1583    
1584    
1585    
1586     // -------------------
1587     // -------------------
1588     // -------------------
1589     // -------------------
1590     // -------------------
1591     // -------------------
1592     // -------------------
1593     // -------------------
1594     // -------------------
1595     // -------------------
1596     // -------------------
1597     // -------------------
1598     // -------------------
1599     // -------------------
1600     // -------------------
1601     // -------------------
1602     // -------------------
1603     // -------------------
1604     // -------------------
1605     // -------------------
1606     // -------------------
1607     // -------------------
1608     // -------------------
1609     // -------------------
1610     // -------------------
1611     // -------------------
1612     // -------------------
1613     // -------------------
1614     // -------------------
1615     // -------------------
1616     // -------------------
1617     // -------------------
1618    
1619    
1620    
1621    
1622    
1623    
1624    
1625    
1626    
1627    
1628    
1629     #if 0
1630     static void c_draw_line3_fast_width(uint32_t *map_buffer, int line_width, int height, int x1, int y1, int x2, int y2, int r, int g, int b, int a, int width)
1631     {
1632     // dbg(0,"rgba:%d %d %d %d\n", r, b, g, a);
1633    
1634    
1635     if (width == 1)
1636     {
1637     c_draw_line3_fast(map_buffer, line_width, height, x1, y1, x2, y2, r, g, b, a);
1638     }
1639     else
1640     {
1641     uint32_t color = createPixel(r, g, b, a);
1642     //c_draw_line3_fast(map_buffer, line_width, height, x1, y1, x2, y2, r, g, b, a);
1643    
1644     //drawThickLine (map_buffer, line_width, height, x1, y1, x2, y2, width, LINE_THICKNESS_MIDDLE, color);
1645     drawThickLineSimple(map_buffer, line_width, height, x1, y1, x2, y2, width, LINE_THICKNESS_MIDDLE, color);
1646     }
1647    
1648    
1649    
1650     #if 0
1651     uint32_t color;
1652    
1653     int cx = (int)(line_width / 2.0f);
1654     int cy = (int)(height / 2.0f);
1655     int dl = 150;
1656     int dm = 20;
1657    
1658     int ww = 10;
1659    
1660    
1661     // nach: links unten steil (gelb)
1662     dbg(0,"bitmap:lu steil\n");
1663     color = createPixel(255, 255, 0, 255);
1664     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx - dm, cy + dl, color, ww);
1665     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx - dm, cy + dl, 255, 255, 0, 255);
1666     drawThickLine(map_buffer, line_width, height, cx, cy, cx - dm, cy + dl, ww, LINE_THICKNESS_MIDDLE, color);
1667     dbg(0,"bitmap:lu steil\n");
1668    
1669    
1670     // nach: rechts unten steil (rot)
1671     dbg(0,"bitmap:ru steil\n");
1672     color = createPixel(255, 0, 0, 255);
1673     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx + dm, cy + dl, color, ww);
1674     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx + dm, cy + dl, 255, 0, 0, 255);
1675     drawThickLine(map_buffer, line_width, height, cx, cy, cx + dm, cy + dl, ww, LINE_THICKNESS_MIDDLE, color);
1676     dbg(0,"bitmap:ru steil\n");
1677    
1678    
1679     // nach: rechts unten flach (grün)
1680     dbg(0,"bitmap:ru flach\n");
1681     color = createPixel(0, 255, 0, 255);
1682     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx + dl, cy + dm, color, ww);
1683     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx + dl, cy + dm, 0, 255, 0, 255);
1684     drawThickLine(map_buffer, line_width, height, cx, cy, cx + dl, cy + dm, ww, LINE_THICKNESS_MIDDLE, color);
1685    
1686     dbg(0,"bitmap:ru flach\n");
1687    
1688    
1689     // nach: rechts oben flach (blau) XX
1690     dbg(0,"bitmap:ro flach\n");
1691     color = createPixel(0, 0, 255, 255);
1692     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx + dl, cy - dm, color, ww);
1693     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx + dl, cy - dm, 0, 0, 255, 255);
1694     drawThickLine(map_buffer, line_width, height, cx, cy, cx + dl, cy - dm, ww, LINE_THICKNESS_MIDDLE, color);
1695     dbg(0,"bitmap:ro flach\n");
1696    
1697    
1698     // nach: rechts oben steil (türkis)
1699     dbg(0,"bitmap:ro steil\n");
1700     color = createPixel(0, 255, 255, 255);
1701     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx + dm, cy - dl, color, 6);
1702     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx + dm, cy - dl, 0, 255, 255, 255);
1703     drawThickLine(map_buffer, line_width, height, cx, cy, cx + dm, cy - dl, ww, LINE_THICKNESS_MIDDLE, color);
1704     dbg(0,"bitmap:ro steil\n");
1705    
1706    
1707     // nach: links oben steil (schwarz)
1708     dbg(0,"bitmap:lo steil\n");
1709     color = createPixel(0, 0, 0, 255);
1710     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx - dm, cy - dl, color, ww);
1711     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx - dm, cy - dl, 0, 0, 0, 255);
1712     drawThickLine(map_buffer, line_width, height, cx, cy, cx - dm, cy - dl, ww, LINE_THICKNESS_MIDDLE, color);
1713     dbg(0,"bitmap:lo steil\n");
1714    
1715    
1716     // nach: links oben flach (pink)
1717     dbg(0,"bitmap:lo flach\n");
1718     color = createPixel(255, 0, 255, 255);
1719     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx - dl, cy - dm, color, ww);
1720     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx - dl, cy - dm, 255, 0, 255, 255);
1721     drawThickLine(map_buffer, line_width, height, cx, cy, cx - dl, cy - dm, ww, LINE_THICKNESS_MIDDLE, color);
1722     dbg(0,"bitmap:lo flach\n");
1723    
1724     // nach: links unten flach (braun) XX
1725     dbg(0,"bitmap:lu flach\n");
1726     color = createPixel(130, 78, 6, 255);
1727     //murphy_wideline(map_buffer, line_width, height, cx, cy, cx - dl, cy + dm, color, ww);
1728     //c_draw_line3_fast(map_buffer, line_width, height, cx, cy, cx - dl, cy + dm, 130, 78, 6, 255);
1729     drawThickLine(map_buffer, line_width, height, cx, cy, cx - dl, cy + dm, ww, LINE_THICKNESS_MIDDLE, color);
1730     dbg(0,"bitmap:lu flach\n");
1731     #endif
1732    
1733     }
1734     #endif
1735    
1736    
1737     /*
1738     *
1739     *
1740     * ********* DRAW normal lines *********
1741     *
1742     *
1743     */
1744     static void draw_lines3(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count, int order, int width, int dashes, struct color *c, int clinedrawing_mode_active, int with_end)
1745     {
1746 zoff99 30 //DBG // dbg(0,"EEnter\n");
1747 zoff99 2 int i;
1748     if (count <= 0)
1749 zoff99 28 {
1750 zoff99 2 return;
1751 zoff99 28 }
1752 zoff99 29
1753 zoff99 40 // dbg(0, "count=%d\n", count);
1754    
1755 zoff99 29 JNIEnv *jnienv2;
1756     jnienv2 = jni_getenv();
1757    
1758 zoff99 40 if (clinedrawing_mode_active)
1759     {
1760    
1761     // ---------- c linedrawing ------------
1762     // ---------- c linedrawing ------------
1763     // ---------- c linedrawing ------------
1764     // ---------- c linedrawing ------------
1765     // ---------- c linedrawing ------------
1766    
1767    
1768     if (main_map_bitmapinfo == NULL)
1769     {
1770     int ret;
1771     main_map_bitmapinfo = &main_map_bitmapinfo2;
1772    
1773     if ((ret = AndroidBitmap_getInfo(jnienv2, main_map_bitmap, main_map_bitmapinfo)) < 0)
1774     {
1775     //dbg(0, "AndroidBitmap_getInfo() failed ! error=%d", ret);
1776     // main_map_bitmapinfo = NULL;
1777     }
1778    
1779     //dbg(0, "bitmap image :: width is %d; height is %d; stride is %d; format is %d;flags is %d", main_map_bitmapinfo2.width,main_map_bitmapinfo2.height,main_map_bitmapinfo2.stride,main_map_bitmapinfo2.format,main_map_bitmapinfo2.flags);
1780    
1781     if (main_map_bitmapinfo2.format == ANDROID_BITMAP_FORMAT_RGBA_8888)
1782     {
1783     //dbg(0, "Bitmap format is RGBA_8888 !");
1784     }
1785     else if (main_map_bitmapinfo2.format == ANDROID_BITMAP_FORMAT_RGB_565)
1786     {
1787     //dbg(0, "Bitmap format is RGB_565 !");
1788     }
1789     else if (main_map_bitmapinfo2.format == ANDROID_BITMAP_FORMAT_RGBA_4444)
1790     {
1791     //dbg(0, "Bitmap format is RGBA_4444 !");
1792     }
1793     }
1794    
1795    
1796     if (main_map_bitmapinfo != NULL)
1797     {
1798     int ret;
1799     void* pixels;
1800    
1801     if ((ret = AndroidBitmap_lockPixels(jnienv2, main_map_bitmap, &pixels)) < 0)
1802     {
1803     // dbg(0, "AndroidBitmap_lockPixels() failed ! error=%d", ret);
1804     }
1805     else
1806     {
1807     if (count > 1)
1808     {
1809     uint32_t color = createPixel(c->r >> 8, c->g >> 8, c->b >> 8, c->a >> 8);
1810    
1811     for (i = 0; i < (count - 1); i++)
1812     {
1813     // drawThickLine ((uint32_t*)pixels, main_map_bitmapinfo->width, main_map_bitmapinfo->height, p[i].x, p[i].y, p[i + 1].x, p[i + 1].y, width, LINE_THICKNESS_MIDDLE, color, c->a >> 8);
1814     drawThickLineSimple((uint32_t*)pixels, main_map_bitmapinfo->width, main_map_bitmapinfo->height, p[i].x, p[i].y, p[i + 1].x, p[i + 1].y, width, LINE_THICKNESS_MIDDLE, color, c->a >> 8);
1815     //c_draw_line3_fast((uint32_t*)pixels, main_map_bitmapinfo->width, main_map_bitmapinfo->height, p[i].x, p[i].y, p[i + 1].x, p[i + 1].y, 0, 0, 0, 255);
1816     }
1817     }
1818     else
1819     {
1820     // dbg(0, "bitmap:b line count=%d\n", count);
1821     }
1822    
1823     AndroidBitmap_unlockPixels(jnienv2, main_map_bitmap);
1824     }
1825     }
1826     // ---------- c linedrawing ------------
1827     // ---------- c linedrawing ------------
1828     // ---------- c linedrawing ------------
1829     // ---------- c linedrawing ------------
1830     // ---------- c linedrawing ------------
1831    
1832     }
1833     else
1834     {
1835    
1836    
1837     // ------- java linedrawing ------------
1838     // ------- java linedrawing ------------
1839     // ------- java linedrawing ------------
1840     // ------- java linedrawing ------------
1841     // ------- java linedrawing ------------
1842    
1843    
1844     jintArray points;
1845     jint pc[count * 2];
1846    
1847 zoff99 29 points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1848 zoff99 27 for (i = 0; i < count; i++)
1849     {
1850     pc[i * 2] = p[i].x;
1851     pc[i * 2 + 1] = p[i].y;
1852 zoff99 2 }
1853 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1854 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline3, points, order, width, dashes, c->r >> 8, c->g >> 8, c->b >> 8, c->a >> 8, with_end);
1855 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, points);
1856 zoff99 40
1857     // ------- java linedrawing ------------
1858     // ------- java linedrawing ------------
1859     // ------- java linedrawing ------------
1860     // ------- java linedrawing ------------
1861     // ------- java linedrawing ------------
1862    
1863     }
1864    
1865 zoff99 2 }
1866    
1867 zoff99 40 static void draw_lines4(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count, int order, int width, int type, int dashes, struct color *c, int with_end)
1868 zoff99 27 {
1869 zoff99 30 //DBG // dbg(0,"EEnter\n");
1870 zoff99 2
1871 zoff99 27 // draw tunnel-street or bridge-street
1872 zoff99 30 // type:1 -> tunnel
1873     // type:2 -> bridge
1874     // ------------------------------------------
1875     // type > 90 -> some signal (not a real line)
1876 zoff99 27
1877 zoff99 29 JNIEnv *jnienv2;
1878     jnienv2 = jni_getenv();
1879    
1880    
1881     if (type > 90)
1882 zoff99 27 {
1883 zoff99 29 // "***" signal
1884 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline4, NULL, order, width, type, 0, 0, 0, 0, 0, with_end);
1885 zoff99 27 }
1886 zoff99 29 else
1887 zoff99 27 {
1888 zoff99 29 jint pc[count * 2];
1889     int i;
1890     jintArray points;
1891     if (count <= 0)
1892     {
1893     return;
1894     }
1895     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1896     for (i = 0; i < count; i++)
1897     {
1898     pc[i * 2] = p[i].x;
1899     pc[i * 2 + 1] = p[i].y;
1900     }
1901 zoff99 30 // initPaint(gra, gc);
1902 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1903 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline4, points, order, width, type, dashes, c->r >> 8, c->g >> 8, c->b >> 8, c->a >> 8, with_end);
1904 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, points);
1905 zoff99 27 }
1906     }
1907    
1908 zoff99 40 // ---------------------------------
1909     // draw oneway arrow ---------------
1910     // ---------------------------------
1911 zoff99 27 static void draw_lines2(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count, int order, int oneway)
1912 zoff99 2 {
1913 zoff99 40 // dbg(0,"EEnter\n");
1914 zoff99 27 jint pc[count * 2];
1915 zoff99 2 int i;
1916     jintArray points;
1917     if (count <= 0)
1918 zoff99 40 {
1919 zoff99 2 return;
1920 zoff99 40 }
1921 zoff99 29
1922     JNIEnv *jnienv2;
1923     jnienv2 = jni_getenv();
1924    
1925     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1926 zoff99 27 for (i = 0; i < count; i++)
1927     {
1928     pc[i * 2] = p[i].x;
1929     pc[i * 2 + 1] = p[i].y;
1930 zoff99 2 }
1931 zoff99 40 // initPaint(gra, gc);
1932 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1933 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline2, points, order, oneway);
1934 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, points);
1935 zoff99 27 }
1936    
1937     static void draw_lines_dashed(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count, int order, int oneway)
1938     {
1939     jint pc[count * 2];
1940     int i;
1941     jintArray points;
1942     if (count <= 0)
1943     return;
1944 zoff99 29
1945     JNIEnv *jnienv2;
1946     jnienv2 = jni_getenv();
1947    
1948     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1949 zoff99 27 for (i = 0; i < count; i++)
1950     {
1951     pc[i * 2] = p[i].x;
1952     pc[i * 2 + 1] = p[i].y;
1953     }
1954     initPaint(gra, gc);
1955 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1956     (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polyline_dashed, gc->gra->Paint, points, order, oneway);
1957     (*jnienv2)->DeleteLocalRef(jnienv2, points);
1958 zoff99 2 }
1959    
1960 zoff99 27 static void draw_polygon(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count)
1961 zoff99 2 {
1962 zoff99 27 jint pc[count * 2];
1963 zoff99 2 int i;
1964     jintArray points;
1965     if (count <= 0)
1966     return;
1967 zoff99 29
1968     JNIEnv *jnienv2;
1969     jnienv2 = jni_getenv();
1970    
1971     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
1972 zoff99 27 for (i = 0; i < count; i++)
1973     {
1974     pc[i * 2] = p[i].x;
1975     pc[i * 2 + 1] = p[i].y;
1976 zoff99 2 }
1977 zoff99 50
1978     // dbg(0, "CCCC:%d %d %d %d\n", gc->r, gc->g, gc->b, gc->a);
1979    
1980 zoff99 40 // initPaint(gra, gc);
1981 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
1982 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polygon, points, gc->linewidth, gc->r, gc->g, gc->b, gc->a);
1983 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, points);
1984 zoff99 2 }
1985    
1986 zoff99 40
1987     /* not used anymore */
1988     /* not used anymore */
1989 zoff99 27 static void draw_polygon2(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int count, int order, int oneway)
1990 zoff99 2 {
1991 zoff99 27 jint pc[count * 2];
1992 zoff99 2 int i;
1993     jintArray points;
1994     if (count <= 0)
1995     return;
1996 zoff99 29
1997     JNIEnv *jnienv2;
1998     jnienv2 = jni_getenv();
1999    
2000     points = (*jnienv2)->NewIntArray(jnienv2, count * 2);
2001 zoff99 27 for (i = 0; i < count; i++)
2002     {
2003     pc[i * 2] = p[i].x;
2004     pc[i * 2 + 1] = p[i].y;
2005 zoff99 2 }
2006     initPaint(gra, gc);
2007 zoff99 29 (*jnienv2)->SetIntArrayRegion(jnienv2, points, 0, count * 2, pc);
2008     (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_polygon2, gc->gra->Paint, points, order, oneway);
2009     (*jnienv2)->DeleteLocalRef(jnienv2, points);
2010 zoff99 2 }
2011    
2012 zoff99 27 static void draw_rectangle(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int w, int h)
2013 zoff99 2 {
2014 zoff99 29 JNIEnv *jnienv2;
2015     jnienv2 = jni_getenv();
2016    
2017 zoff99 27 initPaint(gra, gc);
2018 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_rectangle, gc->gra->Paint, p->x, p->y, w, h);
2019 zoff99 2 }
2020    
2021 zoff99 27 static void draw_circle(struct graphics_priv *gra, struct graphics_gc_priv *gc, struct point *p, int r)
2022 zoff99 2 {
2023 zoff99 29 JNIEnv *jnienv2;
2024     jnienv2 = jni_getenv();
2025    
2026 zoff99 34 // use gc->linewidth as width;
2027    
2028 zoff99 27 initPaint(gra, gc);
2029 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_circle, gc->gra->Paint, p->x, p->y, r);
2030 zoff99 2 }
2031    
2032 zoff99 27 static void draw_text(struct graphics_priv *gra, struct graphics_gc_priv *fg, struct graphics_gc_priv *bg, struct graphics_font_priv *font, char *text, struct point *p, int dx, int dy)
2033 zoff99 2 {
2034 zoff99 27 //// dbg(1, "enter %s\n", text);
2035 zoff99 29 JNIEnv *jnienv2;
2036     jnienv2 = jni_getenv();
2037    
2038 zoff99 40 // initPaint(gra, fg);
2039 zoff99 29 jstring string = (*jnienv2)->NewStringUTF(jnienv2, text);
2040 zoff99 40 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_text, p->x, p->y, string, font->size, dx, dy, fg->r, fg->g, fg->b, fg->a);
2041 zoff99 29 (*jnienv2)->DeleteLocalRef(jnienv2, string);
2042 zoff99 2 }
2043    
2044 zoff99 27 static void draw_image(struct graphics_priv *gra, struct graphics_gc_priv *fg, struct point *p, struct graphics_image_priv *img)
2045 zoff99 2 {
2046 zoff99 30 //DBG // dbg(0,"EEnter\n");
2047 zoff99 2
2048 zoff99 29 JNIEnv *jnienv2;
2049     jnienv2 = jni_getenv();
2050    
2051 zoff99 27 //// dbg(1, "enter %p\n", img);
2052 zoff99 40 // initPaint(gra, fg);
2053     (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_image, p->x, p->y, img->Bitmap, fg->r, fg->g, fg->b, fg->a);
2054 zoff99 27
2055 zoff99 2 }
2056    
2057 zoff99 27 static void draw_bigmap(struct graphics_priv *gra, struct graphics_gc_priv *fg, int yaw, int order, float clat, float clng, int x, int y, int scx, int scy, int px, int py, int valid)
2058 zoff99 2 {
2059 zoff99 30 //DBG // dbg(0,"EEnter\n");
2060 zoff99 2
2061 zoff99 29 JNIEnv *jnienv2;
2062     jnienv2 = jni_getenv();
2063 zoff99 27
2064 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_bigmap, yaw, order, clat, clng, x, y, scx, scy, px, py, valid);
2065    
2066 zoff99 30 //DBG // dbg(0,"leave\n");
2067 zoff99 2 }
2068    
2069 zoff99 27 static void draw_image_warp(struct graphics_priv *gr, struct graphics_gc_priv *fg, struct point *p, int count, char *data)
2070 zoff99 2 {
2071 zoff99 34 //dbg(0,"draw_image_warp:filename=%s\n", data);
2072     //dbg(0,"draw_image_warp:count=%d\n", count);
2073    
2074     /*
2075     void imlib_render_image_on_drawable_skewed(int source_x, int source_y,
2076     int source_width,
2077     int source_height,
2078     int destination_x,
2079     int destination_y,
2080     int h_angle_x, int h_angle_y,
2081     int v_angle_x, int v_angle_y);
2082    
2083     if (count == 3) {
2084     imlib_render_image_on_drawable_skewed(0, 0, w, h, p[0].x, p[0].y, p[1].x-p[0].x, p[1].y-p[0].y, p[2].x-p[0].x, p[2].y-p[0].y);
2085     }
2086     if (count == 2) {
2087     imlib_render_image_on_drawable_skewed(0, 0, w, h, p[0].x, p[0].y, p[1].x-p[0].x, 0, 0, p[1].y-p[0].y);
2088     }
2089     if (count == 1) {
2090     imlib_render_image_on_drawable_skewed(0, 0, w, h, p[0].x-w/2, p[0].y-h/2, w, 0, 0, h);
2091     }
2092    
2093     */
2094    
2095     JNIEnv *jnienv2;
2096     jnienv2 = jni_getenv();
2097    
2098     jstring string = (*jnienv2)->NewStringUTF(jnienv2, data);
2099    
2100     if (count == 3)
2101     {
2102     /* 0 1
2103     2 */
2104     (*jnienv2)->CallVoidMethod(jnienv2, gr->NavitGraphics, gr->NavitGraphics_draw_image_warp, string, count, p[0].x, p[0].y, p[1].x, p[1].y, p[2].x, p[2].y);
2105     }
2106     else if (count == 2)
2107     {
2108     /* 0
2109     1 */
2110     (*jnienv2)->CallVoidMethod(jnienv2, gr->NavitGraphics, gr->NavitGraphics_draw_image_warp, string, count, p[0].x, p[0].y, p[1].x, p[1].y, 0, 0);
2111     }
2112     else if (count == 1)
2113     {
2114     /*
2115     0
2116     */
2117     (*jnienv2)->CallVoidMethod(jnienv2, gr->NavitGraphics, gr->NavitGraphics_draw_image_warp, string, count, p[0].x, p[0].y, 0, 0, 0, 0);
2118     }
2119    
2120     (*jnienv2)->DeleteLocalRef(jnienv2, string);
2121    
2122 zoff99 2 }
2123    
2124 zoff99 27 static void draw_restore(struct graphics_priv *gr, struct point *p, int w, int h)
2125 zoff99 2 {
2126     }
2127    
2128     static void draw_drag(struct graphics_priv *gra, struct point *p)
2129     {
2130 zoff99 30 //DBG // dbg(0,"EEnter\n");
2131 zoff99 29 JNIEnv *jnienv2;
2132     jnienv2 = jni_getenv();
2133 zoff99 2
2134 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_drag, p ? p->x : 0, p ? p->y : 0);
2135 zoff99 2 }
2136    
2137 zoff99 27 static void background_gc(struct graphics_priv *gr, struct graphics_gc_priv *gc)
2138 zoff99 2 {
2139     }
2140    
2141 zoff99 27 static void draw_mode(struct graphics_priv *gra, enum draw_mode_num mode)
2142 zoff99 2 {
2143 zoff99 30 //DBG // dbg(0,"EEnter\n");
2144 zoff99 29 JNIEnv *jnienv2;
2145     jnienv2 = jni_getenv();
2146 zoff99 2
2147 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_draw_mode, (int) mode);
2148 zoff99 2 }
2149    
2150 zoff99 30 static struct graphics_priv * overlay_new(const char* name, struct graphics_priv *gr, struct graphics_methods *meth, struct point *p, int w, int h, int alpha, int wraparound);
2151 zoff99 2
2152     static void *
2153     get_data(struct graphics_priv *this, const char *type)
2154     {
2155 zoff99 30 //DBG // dbg(0,"EEnter\n");
2156 zoff99 2
2157 zoff99 27 if (strcmp(type, "window"))
2158 zoff99 29 {
2159 zoff99 2 return NULL;
2160 zoff99 29 }
2161    
2162 zoff99 2 return &this->win;
2163     }
2164    
2165     static void image_free(struct graphics_priv *gr, struct graphics_image_priv *priv)
2166     {
2167     }
2168    
2169     static void get_text_bbox(struct graphics_priv *gr, struct graphics_font_priv *font, char *text, int dx, int dy, struct point *ret, int estimate)
2170     {
2171 zoff99 30 ////DBG // dbg(0,"EEnter\n");
2172 zoff99 2
2173 zoff99 28 // this is a rough estimate!! otherwise java methods would be called, and thats too slow!
2174    
2175 zoff99 2 int len = g_utf8_strlen(text, -1);
2176     int xMin = 0;
2177     int yMin = 0;
2178 zoff99 27 int yMax = 13 * font->size / 256;
2179     int xMax = 9 * font->size * len / 256;
2180 zoff99 2
2181     ret[0].x = xMin;
2182     ret[0].y = -yMin;
2183     ret[1].x = xMin;
2184     ret[1].y = -yMax;
2185     ret[2].x = xMax;
2186     ret[2].y = -yMax;
2187     ret[3].x = xMax;
2188     ret[3].y = -yMin;
2189     }
2190    
2191     static void overlay_disable(struct graphics_priv *gra, int disable)
2192     {
2193 zoff99 30 // UNUSED ----
2194 zoff99 29
2195 zoff99 30 //DBG // dbg(0,"EEnter\n");
2196     //JNIEnv *jnienv2;
2197     //jnienv2 = jni_getenv();
2198     //
2199     //(*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_overlay_disable, disable);
2200 zoff99 2 }
2201    
2202     static void overlay_resize(struct graphics_priv *gra, struct point *pnt, int w, int h, int alpha, int wraparound)
2203     {
2204 zoff99 30 // UNUSED ----
2205 zoff99 29
2206 zoff99 30 //DBG // dbg(0,"EEnter\n");
2207     //JNIEnv *jnienv2;
2208     //jnienv2 = jni_getenv();
2209     //
2210     //(*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_overlay_resize, pnt ? pnt->x : 0, pnt ? pnt->y : 0, w, h, alpha, wraparound);
2211 zoff99 2 }
2212    
2213 zoff99 27 static int set_attr(struct graphics_priv *gra, struct attr *attr)
2214 zoff99 2 {
2215 zoff99 30 //DBG // dbg(0,"EEnter\n");
2216 zoff99 29 JNIEnv *jnienv2;
2217     jnienv2 = jni_getenv();
2218    
2219 zoff99 27 switch (attr->type)
2220     {
2221     case attr_use_camera:
2222 zoff99 29 (*jnienv2)->CallVoidMethod(jnienv2, gra->NavitGraphics, gra->NavitGraphics_SetCamera, attr->u.num);
2223 zoff99 27 return 1;
2224     default:
2225     return 0;
2226 zoff99 2 }
2227     }
2228    
2229 zoff99 27 static struct graphics_methods graphics_methods =
2230 zoff99 30 { graphics_destroy, draw_mode, draw_lines, draw_lines2, draw_lines3, draw_lines4, draw_lines_dashed, draw_polygon, draw_polygon2, draw_rectangle, draw_circle, draw_text, draw_image, draw_bigmap, draw_image_warp, draw_restore, draw_drag, font_new, gc_new, background_gc, overlay_new, image_new, get_data,
2231 zoff99 27 image_free, get_text_bbox, overlay_disable, overlay_resize, set_attr, };
2232 zoff99 2
2233 zoff99 28 /*
2234 zoff99 27 static void resize_callback(struct graphics_priv *gra, int w, int h)
2235 zoff99 2 {
2236 zoff99 30 //DBG // dbg(0,"EEnter\n");
2237     // //DBG // dbg(0,"w=%d h=%d ok\n",w,h);
2238 zoff99 28 // callback_list_call_attr_2(gra->cbl, attr_resize, (void *) w, (void *) h);
2239     navit_resize(attr_resize, this_);
2240 zoff99 2 }
2241 zoff99 28 */
2242 zoff99 2
2243 zoff99 28 /*
2244 zoff99 27 static void motion_callback(struct graphics_priv *gra, int x, int y)
2245 zoff99 2 {
2246 zoff99 30 //DBG // dbg(0,"EEnter\n");
2247 zoff99 2
2248     struct point p;
2249 zoff99 27 p.x = x;
2250     p.y = y;
2251     callback_list_call_attr_1(gra->cbl, attr_motion, (void *) &p);
2252 zoff99 2 }
2253 zoff99 28 */
2254 zoff99 2
2255 zoff99 28 /*
2256 zoff99 27 static void keypress_callback(struct graphics_priv *gra, char *s)
2257 zoff99 2 {
2258 zoff99 30 //DBG // dbg(0,"EEnter\n");
2259 zoff99 2 callback_list_call_attr_1(gra->cbl, attr_keypress, s);
2260     }
2261 zoff99 28 */
2262 zoff99 2
2263 zoff99 28 /*
2264 zoff99 27 static void button_callback(struct graphics_priv *gra, int pressed, int button, int x, int y)
2265 zoff99 2 {
2266 zoff99 30 //DBG // dbg(0,"EEnter\n");
2267 zoff99 2
2268     struct point p;
2269 zoff99 27 p.x = x;
2270     p.y = y;
2271 zoff99 30 // //DBG // dbg(0,"XXXXXXXYYYYYYYYY\n");
2272 zoff99 27 callback_list_call_attr_3(gra->cbl, attr_button, (void *) pressed, (void *) button, (void *) &p);
2273 zoff99 2 }
2274 zoff99 28 */
2275 zoff99 2
2276 zoff99 27 static int set_activity(jobject graphics)
2277 zoff99 2 {
2278 zoff99 30 // dbg(0,"EEnter\n");
2279     // ---- DISABLED -------
2280 zoff99 2 return 1;
2281     }
2282    
2283 zoff99 30 static int graphics_android_init(const char* name, struct graphics_priv *ret, struct graphics_priv *parent, struct point *pnt, int w, int h, int alpha, int wraparound, int use_camera)
2284 zoff99 2 {
2285     struct callback *cb;
2286    
2287 zoff99 30 // overwrite JNIenv!!
2288     JNIEnv *jnienv2;
2289     jnienv2 = jni_getenv();
2290    
2291     // dbg(0, "at 2 jnienv2=%p\n", jnienv2);
2292     int thread_id = gettid();
2293     // dbg(0, "THREAD ID=%d\n", thread_id);
2294    
2295     //DBG // dbg(0,"a1\n");
2296 zoff99 2 if (!find_class_global("android/graphics/Paint", &ret->PaintClass))
2297     return 0;
2298 zoff99 30 //DBG // dbg(0,"a2\n");
2299 zoff99 2 if (!find_method(ret->PaintClass, "<init>", "(I)V", &ret->Paint_init))
2300     return 0;
2301 zoff99 30 //DBG // dbg(0,"a3\n");
2302 zoff99 2 if (!find_method(ret->PaintClass, "setARGB", "(IIII)V", &ret->Paint_setARGB))
2303     return 0;
2304 zoff99 30 //DBG // dbg(0,"a4\n");
2305 zoff99 2 if (!find_method(ret->PaintClass, "setStrokeWidth", "(F)V", &ret->Paint_setStrokeWidth))
2306     return 0;
2307    
2308 zoff99 30 //DBG // dbg(0,"a4.1\n");
2309 zoff99 2 if (!find_class_global("android/graphics/BitmapFactory", &ret->BitmapFactoryClass))
2310     return 0;
2311 zoff99 30 //DBG // dbg(0,"a4.2\n");
2312 zoff99 2 if (!find_static_method(ret->BitmapFactoryClass, "decodeFile", "(Ljava/lang/String;)Landroid/graphics/Bitmap;", &ret->BitmapFactory_decodeFile))
2313     return 0;
2314 zoff99 30 //DBG // dbg(0,"a4.3\n");
2315 zoff99 2 if (!find_static_method(ret->BitmapFactoryClass, "decodeResource", "(Landroid/content/res/Resources;I)Landroid/graphics/Bitmap;", &ret->BitmapFactory_decodeResource))
2316     return 0;
2317    
2318 zoff99 30 //DBG // dbg(0,"a4.4\n");
2319 zoff99 2 if (!find_class_global("android/graphics/Bitmap", &ret->BitmapClass))
2320     return 0;
2321 zoff99 30 //DBG // dbg(0,"a4.5\n");
2322 zoff99 2 if (!find_method(ret->BitmapClass, "getHeight", "()I", &ret->Bitmap_getHeight))
2323     return 0;
2324 zoff99 30 //DBG // dbg(0,"a4.6\n");
2325 zoff99 2 if (!find_method(ret->BitmapClass, "getWidth", "()I", &ret->Bitmap_getWidth))
2326     return 0;
2327 zoff99 30 //DBG // dbg(0,"a4.7\n");
2328 zoff99 2 if (!find_class_global("android/content/Context", &ret->ContextClass))
2329     return 0;
2330 zoff99 30 //DBG // dbg(0,"a4.8\n");
2331 zoff99 2 if (!find_method(ret->ContextClass, "getResources", "()Landroid/content/res/Resources;", &ret->Context_getResources))
2332     return 0;
2333 zoff99 30 //DBG // dbg(0,"a5\n");
2334     ret->Resources = (*jnienv2)->CallObjectMethod(jnienv2, android_activity, ret->Context_getResources);
2335     //DBG // dbg(0,"a6\n");
2336 zoff99 2 if (ret->Resources)
2337 zoff99 27 {
2338 zoff99 30 ret->Resources = (*jnienv2)->NewGlobalRef(jnienv2, ret->Resources);
2339 zoff99 27 }
2340 zoff99 30 //DBG // dbg(0,"a7\n");
2341 zoff99 2 if (!find_class_global("android/content/res/Resources", &ret->ResourcesClass))
2342     return 0;
2343 zoff99 30 //DBG // dbg(0,"a8\n");
2344 zoff99 2 if (!find_method(ret->ResourcesClass, "getIdentifier", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I", &ret->Resources_getIdentifier))
2345     return 0;
2346 zoff99 30 //DBG // dbg(0,"a9\n");
2347 zoff99 2 if (!find_class_global("com/zoffcc/applications/zanavi/NavitGraphics", &ret->NavitGraphicsClass))
2348     return 0;
2349 zoff99 30 //DBG // dbg(0, "at 3\n");
2350    
2351    
2352     // --------------- Init the new Graphics Object here -----------------
2353     // --------------- Init the new Graphics Object here -----------------
2354     // --------------- Init the new Graphics Object here -----------------
2355     // dbg(0,"Init the new Graphics Object here: %s\n", name);
2356    
2357     //DBG // dbg(0, "at 4 android_activity=%p\n", android_activity);
2358    
2359    
2360    
2361    
2362     if (NavitClass2 == NULL)
2363 zoff99 27 {
2364 zoff99 30 if (!android_find_class_global("com/zoffcc/applications/zanavi/Navit", &NavitClass2))
2365     {
2366     NavitClass2 = NULL;
2367     return 0;
2368     }
2369 zoff99 2 }
2370 zoff99 30
2371     if (!find_static_method(NavitClass2, "get_graphics_object_by_name", "(Ljava/lang/String;)Lcom/zoffcc/applications/zanavi/NavitGraphics;", &Navit_get_graphics_object_by_name))
2372     return 0;
2373    
2374    
2375     /// --old-- ret->NavitGraphics = (*jnienv2)->NewObject(jnienv2, ret->NavitGraphicsClass, cid, android_activity, parent ? parent->NavitGraphics : NULL, pnt ? pnt->x : 0, pnt ? pnt->y : 0, w, h, alpha, wraparound, use_camera);
2376    
2377     /// --new--
2378     jstring string = (*jnienv2)->NewStringUTF(jnienv2, name);
2379     ret->NavitGraphics = (*jnienv2)->CallStaticObjectMethod(jnienv2, NavitClass2, Navit_get_graphics_object_by_name, string);
2380     (*jnienv2)->DeleteLocalRef(jnienv2, string);
2381     /// --new--
2382    
2383    
2384     // dbg(0, "result=%p\n", ret->NavitGraphics);
2385 zoff99 2 if (ret->NavitGraphics)
2386 zoff99 27 {
2387 zoff99 30 ret->NavitGraphics = (*jnienv2)->NewGlobalRef(jnienv2, ret->NavitGraphics);
2388 zoff99 27 }
2389 zoff99 2
2390 zoff99 30 // --------------- Init the new Graphics Object here -----------------
2391     // --------------- Init the new Graphics Object here -----------------
2392     // --------------- Init the new Graphics Object here -----------------
2393    
2394    
2395    
2396    
2397    
2398    
2399 zoff99 2 /* Create a single global Paint, otherwise android will quickly run out
2400     * of global refs.*/
2401     /* 0x101 = text kerning (default), antialiasing */
2402 zoff99 30 ret->Paint = (*jnienv2)->NewObject(jnienv2, ret->PaintClass, ret->Paint_init, 0x101);
2403 zoff99 2
2404 zoff99 30 //DBG // dbg(0, "l result=%p\n", ret->Paint);
2405 zoff99 2 if (ret->Paint)
2406 zoff99 27 {
2407 zoff99 30 ret->Paint = (*jnienv2)->NewGlobalRef(jnienv2, ret->Paint);
2408 zoff99 27 }
2409 zoff99 30 //DBG // dbg(0, "g result=%p\n", ret->Paint);
2410 zoff99 2
2411    
2412     // public Bitmap rotate_and_scale_bitmap(Bitmap in, int w, int h, int angle)
2413    
2414     if (!find_static_method(ret->NavitGraphicsClass, "rotate_and_scale_bitmap", "(Landroid/graphics/Bitmap;III)Landroid/graphics/Bitmap;", &ret->NavitGraphicsClass_rotate_and_scale_bitmap))
2415     return 0;
2416 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_polyline", "([IIIIII)V", &ret->NavitGraphics_draw_polyline))
2417 zoff99 2 return 0;
2418 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_polyline2", "([III)V", &ret->NavitGraphics_draw_polyline2))
2419 zoff99 2 return 0;
2420 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_polyline3", "([IIIIIIIII)V", &ret->NavitGraphics_draw_polyline3))
2421 zoff99 27 return 0;
2422 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_polyline4", "([IIIIIIIIII)V", &ret->NavitGraphics_draw_polyline4))
2423 zoff99 27 return 0;
2424 zoff99 2 if (!find_method(ret->NavitGraphicsClass, "draw_polyline_dashed", "(Landroid/graphics/Paint;[III)V", &ret->NavitGraphics_draw_polyline_dashed))
2425     return 0;
2426 zoff99 27 if (!find_method(ret->NavitGraphicsClass, "set_dashes", "(Landroid/graphics/Paint;II)V", &ret->NavitGraphics_set_dashes))
2427     return 0;
2428 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_polygon", "([IIIIII)V", &ret->NavitGraphics_draw_polygon))
2429 zoff99 2 return 0;
2430     if (!find_method(ret->NavitGraphicsClass, "draw_polygon2", "(Landroid/graphics/Paint;[III)V", &ret->NavitGraphics_draw_polygon2))
2431     return 0;
2432     if (!find_method(ret->NavitGraphicsClass, "draw_rectangle", "(Landroid/graphics/Paint;IIII)V", &ret->NavitGraphics_draw_rectangle))
2433     return 0;
2434     if (!find_method(ret->NavitGraphicsClass, "draw_circle", "(Landroid/graphics/Paint;III)V", &ret->NavitGraphics_draw_circle))
2435     return 0;
2436 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_text", "(IILjava/lang/String;IIIIIII)V", &ret->NavitGraphics_draw_text))
2437 zoff99 2 return 0;
2438 zoff99 40 if (!find_method(ret->NavitGraphicsClass, "draw_image", "(IILandroid/graphics/Bitmap;IIII)V", &ret->NavitGraphics_draw_image))
2439 zoff99 2 return 0;
2440     if (!find_method(ret->NavitGraphicsClass, "draw_bigmap", "(IIFFIIIIIII)V", &ret->NavitGraphics_draw_bigmap))
2441     return 0;
2442 zoff99 34 if (!find_method(ret->NavitGraphicsClass, "draw_warp", "(Ljava/lang/String;IIIIIII)V", &ret->NavitGraphics_draw_image_warp))
2443     return 0;
2444 zoff99 30
2445 zoff99 2 if (!find_method(ret->NavitGraphicsClass, "draw_mode", "(I)V", &ret->NavitGraphics_draw_mode))
2446     return 0;
2447     if (!find_method(ret->NavitGraphicsClass, "draw_drag", "(II)V", &ret->NavitGraphics_draw_drag))
2448     return 0;
2449 zoff99 30 //if (!find_method(ret->NavitGraphicsClass, "overlay_disable", "(I)V", &ret->NavitGraphics_overlay_disable))
2450     // return 0;
2451     //if (!find_method(ret->NavitGraphicsClass, "overlay_resize", "(IIIIII)V", &ret->NavitGraphics_overlay_resize))
2452     // return 0;
2453 zoff99 28 /*
2454 zoff99 2 if (!find_method(ret->NavitGraphicsClass, "SetCamera", "(I)V", &ret->NavitGraphics_SetCamera))
2455     return 0;
2456 zoff99 28 */
2457 zoff99 27
2458 zoff99 30 //DBG // dbg(0,"99\n");
2459 zoff99 2 #if 0
2460     set_activity(ret->NavitGraphics);
2461     #endif
2462     return 1;
2463     }
2464    
2465 zoff99 27 static int graphics_android_fullscreen(struct window *win, int on)
2466 zoff99 2 {
2467     return 1;
2468     }
2469    
2470     static jclass NavitClass;
2471     static jmethodID Navit_disableSuspend, Navit_exit;
2472    
2473 zoff99 27 static void graphics_android_disable_suspend(struct window *win)
2474 zoff99 2 {
2475 zoff99 30 //DBG // dbg(0,"enter\n");
2476 zoff99 29 JNIEnv *jnienv2;
2477     jnienv2 = jni_getenv();
2478    
2479     (*jnienv2)->CallVoidMethod(jnienv2, android_activity, Navit_disableSuspend);
2480 zoff99 2 }
2481    
2482 zoff99 40 struct graphics_priv *
2483 zoff99 2 graphics_android_new(struct navit *nav, struct graphics_methods *meth, struct attr **attrs, struct callback_list *cbl)
2484     {
2485 zoff99 30 // dbg(0,"EEnter\n");
2486 zoff99 2
2487 zoff99 30 int thread_id = gettid();
2488     // dbg(0, "THREAD ID=%d\n", thread_id);
2489    
2490 zoff99 2 struct graphics_priv *ret;
2491     struct attr *attr;
2492 zoff99 27 int use_camera = 0;
2493 zoff99 29
2494 zoff99 30 // dbg(0,"event system - start\n");
2495 zoff99 27 if (!event_request_system("android", "graphics_android"))
2496 zoff99 29 {
2497     return NULL;
2498     }
2499 zoff99 30 // dbg(0,"event system - end\n");
2500 zoff99 2
2501 zoff99 29 ret=g_new0(struct graphics_priv, 1);
2502 zoff99 27 ret->cbl = cbl;
2503     *meth = graphics_methods;
2504     ret->win.priv = ret;
2505     ret->win.fullscreen = graphics_android_fullscreen;
2506     ret->win.disable_suspend = graphics_android_disable_suspend;
2507     if ((attr = attr_search(attrs, NULL, attr_use_camera)))
2508     {
2509     use_camera = attr->u.num;
2510 zoff99 2 }
2511     image_cache_hash = g_hash_table_new(g_str_hash, g_str_equal);
2512 zoff99 30
2513    
2514     // --------------- try to get a new Graphics Object -----------------
2515     // --------------- try to get a new Graphics Object -----------------
2516     // --------------- try to get a new Graphics Object -----------------
2517     // dbg(0,"try to get a new Graphics Object\n");
2518     if (graphics_android_init("type:map-main", ret, NULL, NULL, 0, 0, 0, 0, use_camera))
2519 zoff99 27 {
2520 zoff99 30 ////DBG // dbg(0,"returning %p\n",ret);
2521 zoff99 2 return ret;
2522 zoff99 27 }
2523     else
2524     {
2525 zoff99 2 g_free(ret);
2526     return NULL;
2527     }
2528     }
2529    
2530     static struct graphics_priv *
2531 zoff99 30 overlay_new(const char* name, struct graphics_priv *gr, struct graphics_methods *meth, struct point *p, int w, int h, int alpha, int wraparound)
2532 zoff99 2 {
2533 zoff99 30 // dbg(0,"EEnter\n");
2534 zoff99 2
2535 zoff99 30 int thread_id = gettid();
2536     // dbg(0, "THREAD ID=%d\n", thread_id);
2537    
2538 zoff99 2 struct graphics_priv *ret=g_new0(struct graphics_priv, 1);
2539 zoff99 27 *meth = graphics_methods;
2540 zoff99 30
2541     // --------------- try to get a new Graphics Object -----------------
2542     // --------------- try to get a new Graphics Object -----------------
2543     // --------------- try to get a new Graphics Object -----------------
2544     // dbg(0,"try to get a new Graphics Object: %s\n", name);
2545     if (graphics_android_init(name ,ret, gr, p, w, h, alpha, wraparound, 0))
2546 zoff99 27 {
2547 zoff99 30 // dbg(0, "returning %p\n", ret);
2548 zoff99 2 return ret;
2549 zoff99 27 }
2550     else
2551     {
2552 zoff99 2 g_free(ret);
2553     return NULL;
2554     }
2555     }
2556    
2557 zoff99 27 static void event_android_main_loop_run(void)
2558 zoff99 2 {
2559 zoff99 30 // dbg(0, "enter\n");
2560 zoff99 2 }
2561    
2562     static void event_android_main_loop_quit(void)
2563     {
2564 zoff99 30 // dbg(0, "enter\n");
2565    
2566     // overwrite JNIenv!!
2567     JNIEnv *jnienv2;
2568     jnienv2 = jni_getenv();
2569    
2570     int thread_id = gettid();
2571     // dbg(0, "THREAD ID=%d\n", thread_id);
2572    
2573 zoff99 27 // ******* exit(0);
2574 zoff99 30 (*jnienv2)->CallVoidMethod(jnienv2, android_activity, Navit_exit);
2575 zoff99 2 }
2576    
2577     static jclass NavitTimeoutClass;
2578     static jmethodID NavitTimeout_init;
2579     static jmethodID NavitTimeout_remove;
2580    
2581     static jclass NavitIdleClass;
2582     static jmethodID NavitIdle_init;
2583     static jmethodID NavitIdle_remove;
2584    
2585     static jclass NavitWatchClass;
2586     static jmethodID NavitWatch_init;
2587     static jmethodID NavitWatch_remove;
2588    
2589     static struct event_watch *
2590     event_android_add_watch(void *h, enum event_watch_cond cond, struct callback *cb)
2591     {
2592 zoff99 30 // dbg(0,"enter\n");
2593 zoff99 2 jobject ret;
2594 zoff99 27 ret = (*jnienv)->NewObject(jnienv, NavitWatchClass, NavitWatch_init, (int) h, (int) cond, (int) cb);
2595 zoff99 30 // //DBG // dbg(0,"result for %p,%d,%p=%p\n",h,cond,cb,ret);
2596 zoff99 2 if (ret)
2597 zoff99 27 {
2598 zoff99 30 //DBG // dbg(0,"result for %p,%p\n",h,ret);
2599 zoff99 27 ret = (*jnienv)->NewGlobalRef(jnienv, ret);
2600 zoff99 30 //DBG // dbg(0,"g ret %p\n",ret);
2601 zoff99 27 }
2602     return (struct event_watch *) ret;
2603 zoff99 2 }
2604    
2605 zoff99 27 static void event_android_remove_watch(struct event_watch *ev)
2606 zoff99 2 {
2607 zoff99 30 // dbg(0,"enter\n");
2608 zoff99 27 if (ev)
2609     {
2610 zoff99 30 //DBG // dbg(0,"enter %p\n",ev);
2611 zoff99 27 jobject obj = (jobject) ev;
2612     // maybe need this ? ICS obj = (*jnienv)->NewGlobalRef(jnienv, obj);
2613 zoff99 2 (*jnienv)->CallVoidMethod(jnienv, obj, NavitWatch_remove);
2614 zoff99 27 // ICS (*jnienv)->DeleteGlobalRef(jnienv, obj);
2615 zoff99 2 }
2616     }
2617    
2618     static struct event_timeout *
2619     event_android_add_timeout(int timeout, int multi, struct callback *cb)
2620     {
2621 zoff99 30 // dbg(0,"EEnter\n");
2622 zoff99 2
2623 zoff99 30 // overwrite JNIenv!!
2624     JNIEnv *jnienv2;
2625     jnienv2 = jni_getenv();
2626    
2627     int thread_id = gettid();
2628     // dbg(0, "THREAD ID=%d\n", thread_id);
2629    
2630 zoff99 28 // timeout -> delay in milliseconds
2631    
2632 zoff99 2 jobject ret;
2633 zoff99 29 jobject ret_g = NULL;
2634 zoff99 30 ret = (*jnienv2)->NewObject(jnienv2, NavitTimeoutClass, NavitTimeout_init, timeout, multi, (int) cb);
2635     //// dbg(0, "result for %d,%d,%p\n", timeout, multi, cb);
2636 zoff99 27
2637 zoff99 2 if (ret)
2638 zoff99 27 {
2639 zoff99 30 //// dbg(0,"l ret=%p\n",ret);
2640     ret_g = (*jnienv2)->NewGlobalRef(jnienv2, ret);
2641     // dbg(0,"g ret=%p\n",ret_g);
2642 zoff99 27 }
2643 zoff99 30 //// dbg(0,"leave\n");
2644 zoff99 29 return (struct event_timeout *) ret_g;
2645 zoff99 2 }
2646    
2647 zoff99 27 static void event_android_remove_timeout(struct event_timeout *to)
2648 zoff99 2 {
2649 zoff99 30 // dbg(0,"EEnter\n");
2650 zoff99 2
2651 zoff99 30 // overwrite JNIenv!!
2652     JNIEnv *jnienv2;
2653     jnienv2 = jni_getenv();
2654    
2655     // int thread_id = gettid();
2656     // dbg(0, "THREAD ID=%d\n", thread_id);
2657    
2658    
2659 zoff99 27 if (to)
2660     {
2661 zoff99 30 // dbg(0, "remove %p\n", to);
2662 zoff99 27 jobject obj = (jobject) to;
2663 zoff99 30 (*jnienv2)->CallVoidMethod(jnienv2, obj, NavitTimeout_remove);
2664 zoff99 29 // ICS
2665 zoff99 30 //// dbg(0, "remove 1\n");
2666     (*jnienv2)->DeleteGlobalRef(jnienv2, obj);
2667     //// dbg(0, "remove 2\n");
2668 zoff99 2 }
2669     }
2670    
2671     static struct event_idle *
2672     event_android_add_idle(int priority, struct callback *cb)
2673     {
2674 zoff99 28 // ----------------------------------------------------
2675     // ----------------------------------------------------
2676     // "priority" param is now misused here as "multi"
2677     // priority == 1000 -> set multi = 0
2678     // ----------------------------------------------------
2679     // ----------------------------------------------------
2680 zoff99 2
2681 zoff99 30 //// dbg(0,"EEnter\n");
2682 zoff99 28
2683 zoff99 2 #if 0
2684     jobject ret;
2685 zoff99 27 // dbg(1,"enter\n");
2686 zoff99 2 ret=(*jnienv)->NewObject(jnienv, NavitIdleClass, NavitIdle_init, (int)cb);
2687 zoff99 27 // dbg(1,"result for %p=%p\n",cb,ret);
2688 zoff99 2 if (ret)
2689 zoff99 27 (*jnienv)->NewGlobalRef(jnienv, ret);
2690 zoff99 2 return (struct event_idle *)ret;
2691     #endif
2692 zoff99 28 // ----- xxxxxxxx ------
2693     if (priority == 1000)
2694     {
2695 zoff99 30 //dbg(0,"event add idle timeout=10 multi=0\n", priority);
2696 zoff99 28 return (struct event_idle *) event_android_add_timeout(10, 0, cb);
2697     }
2698     else
2699     {
2700 zoff99 30 //dbg(0,"event add idle timeout=%d multi=1\n", priority);
2701     return (struct event_idle *) event_android_add_timeout(priority, 1, cb);
2702 zoff99 28 }
2703 zoff99 2 }
2704    
2705 zoff99 27 static void event_android_remove_idle(struct event_idle *ev)
2706 zoff99 2 {
2707 zoff99 30 //// dbg(0,"EEnter\n");
2708 zoff99 2
2709     #if 0
2710 zoff99 27 // dbg(1,"enter %p\n",ev);
2711     if (ev)
2712     {
2713 zoff99 2 jobject obj=(jobject )ev;
2714     (*jnienv)->CallVoidMethod(jnienv, obj, NavitIdle_remove);
2715     (*jnienv)->DeleteGlobalRef(jnienv, obj);
2716     }
2717     #endif
2718 zoff99 27 event_android_remove_timeout((struct event_timeout *) ev);
2719 zoff99 2 }
2720    
2721 zoff99 27 static void event_android_call_callback(struct callback_list *cb)
2722 zoff99 2 {
2723 zoff99 30 //DBG // dbg(0,"enter\n");
2724 zoff99 2 }
2725    
2726 zoff99 27 static struct event_methods event_android_methods =
2727     { event_android_main_loop_run, event_android_main_loop_quit, event_android_add_watch, event_android_remove_watch, event_android_add_timeout, event_android_remove_timeout, event_android_add_idle, event_android_remove_idle, event_android_call_callback, };
2728 zoff99 2
2729 zoff99 40 struct event_priv *
2730 zoff99 2 event_android_new(struct event_methods *meth)
2731     {
2732 zoff99 30
2733     // overwrite JNIenv!!
2734     JNIEnv *jnienv2;
2735     jnienv2 = jni_getenv();
2736    
2737     // int thread_id = gettid();
2738     // dbg(0, "THREAD ID=%d\n", thread_id);
2739    
2740    
2741     // dbg(0,"enter\n");
2742 zoff99 2 if (!find_class_global("com/zoffcc/applications/zanavi/NavitTimeout", &NavitTimeoutClass))
2743     return NULL;
2744 zoff99 30
2745     // dbg(0,"ev 001\n");
2746     NavitTimeout_init = (*jnienv2)->GetMethodID(jnienv2, NavitTimeoutClass, "<init>", "(IZI)V");
2747 zoff99 27 if (NavitTimeout_init == NULL)
2748 zoff99 2 return NULL;
2749 zoff99 30 // dbg(0,"ev 002\n");
2750     NavitTimeout_remove = (*jnienv2)->GetMethodID(jnienv2, NavitTimeoutClass, "remove", "()V");
2751 zoff99 27 if (NavitTimeout_remove == NULL)
2752 zoff99 2 return NULL;
2753     #if 0
2754     if (!find_class_global("com/zoffcc/applications/zanavi/NavitIdle", &NavitIdleClass))
2755 zoff99 27 return NULL;
2756 zoff99 30 NavitIdle_init = (*jnienv2)->GetMethodID(jnienv2, NavitIdleClass, "<init>", "(I)V");
2757 zoff99 27 if (NavitIdle_init == NULL)
2758     return NULL;
2759 zoff99 30 NavitIdle_remove = (*jnienv2)->GetMethodID(jnienv2, NavitIdleClass, "remove", "()V");
2760 zoff99 27 if (NavitIdle_remove == NULL)
2761     return NULL;
2762 zoff99 2 #endif
2763    
2764 zoff99 30 // dbg(0,"ev 003\n");
2765 zoff99 2 if (!find_class_global("com/zoffcc/applications/zanavi/NavitWatch", &NavitWatchClass))
2766     return NULL;
2767 zoff99 30 // dbg(0,"ev 004\n");
2768     NavitWatch_init = (*jnienv2)->GetMethodID(jnienv2, NavitWatchClass, "<init>", "(III)V");
2769 zoff99 27 if (NavitWatch_init == NULL)
2770 zoff99 2 return NULL;
2771 zoff99 30 // dbg(0,"ev 005\n");
2772     NavitWatch_remove = (*jnienv2)->GetMethodID(jnienv2, NavitWatchClass, "remove", "()V");
2773 zoff99 27 if (NavitWatch_remove == NULL)
2774 zoff99 2 return NULL;
2775    
2776 zoff99 30 // dbg(0,"ev 006\n");
2777 zoff99 2 if (!find_class_global("com/zoffcc/applications/zanavi/Navit", &NavitClass))
2778     return NULL;
2779 zoff99 30 // dbg(0,"ev 007\n");
2780     Navit_disableSuspend = (*jnienv2)->GetMethodID(jnienv2, NavitClass, "disableSuspend", "()V");
2781 zoff99 27 if (Navit_disableSuspend == NULL)
2782 zoff99 2 return NULL;
2783 zoff99 30 // dbg(0,"ev 008\n");
2784     Navit_exit = (*jnienv2)->GetMethodID(jnienv2, NavitClass, "exit2", "()V");
2785 zoff99 27 if (Navit_exit == NULL)
2786 zoff99 2 return NULL;
2787 zoff99 30
2788     // dbg(0,"ok\n");
2789    
2790 zoff99 27 *meth = event_android_methods;
2791     return NULL;
2792 zoff99 2 }
2793    
2794 zoff99 40 #ifdef PLUGSSS
2795 zoff99 27 void plugin_init(void)
2796 zoff99 2 {
2797 zoff99 31 dbg(0,"enter\n");
2798 zoff99 27 plugin_register_graphics_type("android", graphics_android_new);
2799 zoff99 2 plugin_register_event_type("android", event_android_new);
2800     }
2801 zoff99 40 #endif
2802 zoff99 27

   
Visit the ZANavi Wiki