git.maemo.org Git - navit-package/blob - navit/graphics.c

   1 /**
   2  * Navit, a modular navigation system.
   3  * Copyright (C) 2005-2008 Navit Team
   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 //#
  22 //# File: graphics.c
  23 //# Description:
  24 //# Comment:
  25 //# Authors: Martin Schaller (04/2008)
  26 //#
  27 //##############################################################################################################
  28
  29 #include <glib.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <math.h>
  33 #include "debug.h"
  34 #include "string.h"
  35 #include "draw_info.h"
  36 #include "point.h"
  37 #include "graphics.h"
  38 #include "projection.h"
  39 #include "item.h"
  40 #include "map.h"
  41 #include "coord.h"
  42 #include "transform.h"
  43 #include "plugin.h"
  44 #include "profile.h"
  45 #include "mapset.h"
  46 #include "layout.h"
  47 #include "route.h"
  48 #include "util.h"
  49 #include "callback.h"
  50 #include "file.h"
  51
  52 static char *navit_sharedir;
  53
  54 //##############################################################################################################
  55 //# Description:
  56 //# Comment:
  57 //# Authors: Martin Schaller (04/2008)
  58 //##############################################################################################################
  59 struct graphics
  60 {
  61         struct graphics_priv *priv;
  62         struct graphics_methods meth;
  63         char *default_font;
  64         struct graphics_font *font[16];
  65         struct graphics_gc *gc[3];
  66         struct attr **attrs;
  67         struct callback_list *cbl;
  68         int ready;
  69         struct point_rect r;
  70 };
  71
  72
  73 struct displaylist {
  74         GHashTable *dl;
  75 };
  76
  77
  78 void
  79 graphics_set_rect(struct graphics *gra, struct point_rect *pr)
  80 {
  81         gra->r=*pr;
  82 }
  83
  84 /**
  85  * Creates a new graphics object
  86  * attr type required
  87  * @param <>
  88  * @returns <>
  89  * @author Martin Schaller (04/2008)
  90 */
  91 struct graphics * graphics_new(struct attr *parent, struct attr **attrs)
  92 {
  93         struct graphics *this_;
  94         struct attr *type_attr;
  95         struct graphics_priv * (*graphicstype_new)(struct navit *nav, struct graphics_methods *meth, struct attr **attrs, struct callback_list *cbl);
  96
  97         if (! (type_attr=attr_search(attrs, NULL, attr_type))) {
  98                 return NULL;
  99         }
 100
 101         graphicstype_new=plugin_get_graphics_type(type_attr->u.str);
 102         if (! graphicstype_new)
 103                 return NULL;
 104         this_=g_new0(struct graphics, 1);
 105         this_->cbl=callback_list_new();
 106         this_->priv=(*graphicstype_new)(parent->u.navit, &this_->meth, attrs, this_->cbl);
 107         this_->attrs=attr_list_dup(attrs);
 108         return this_;
 109 }
 110
 111 /**
 112  * FIXME
 113  * @param <>
 114  * @returns <>
 115  * @author Martin Schaller (04/2008)
 116 */
 117 int graphics_get_attr(struct graphics *this_, enum attr_type type, struct attr *attr, struct attr_iter *iter)
 118 {
 119         return attr_generic_get_attr(this_->attrs, NULL, type, attr, iter);
 120 }
 121
 122 /**
 123  * FIXME
 124  * @param <>
 125  * @returns <>
 126  * @author Martin Schaller (04/2008)
 127 */
 128 struct graphics * graphics_overlay_new(struct graphics *parent, struct point *p, int w, int h, int alpha, int wraparound)
 129 {
 130         struct graphics *this_;
 131         if (!parent->meth.overlay_new)
 132                 return NULL;
 133         this_=g_new0(struct graphics, 1);
 134         this_->priv=parent->meth.overlay_new(parent->priv, &this_->meth, p, w, h, alpha, wraparound);
 135         if (!this_->priv) {
 136                 g_free(this_);
 137                 this_=NULL;
 138         }
 139         return this_;
 140 }
 141
 142 /**
 143  * FIXME
 144  * @param <>
 145  * @returns <>
 146  * @author Martin Schaller (04/2008)
 147 */
 148 void graphics_init(struct graphics *this_)
 149 {
 150         this_->gc[0]=graphics_gc_new(this_);
 151         graphics_gc_set_background(this_->gc[0], &(struct color) { 0xffff, 0xefef, 0xb7b7, 0xffff});
 152         graphics_gc_set_foreground(this_->gc[0], &(struct color) { 0xffff, 0xefef, 0xb7b7, 0xffff });
 153         this_->gc[1]=graphics_gc_new(this_);
 154         graphics_gc_set_background(this_->gc[1], &(struct color) { 0x0000, 0x0000, 0x0000, 0xffff });
 155         graphics_gc_set_foreground(this_->gc[1], &(struct color) { 0xffff, 0xffff, 0xffff, 0xffff });
 156         this_->gc[2]=graphics_gc_new(this_);
 157         graphics_gc_set_background(this_->gc[2], &(struct color) { 0xffff, 0xffff, 0xffff, 0xffff });
 158         graphics_gc_set_foreground(this_->gc[2], &(struct color) { 0x0000, 0x0000, 0x0000, 0xffff });
 159         graphics_background_gc(this_, this_->gc[0]);
 160         navit_sharedir = getenv("NAVIT_SHAREDIR");
 161 }
 162
 163 /**
 164  * FIXME
 165  * @param <>
 166  * @returns <>
 167  * @author Martin Schaller (04/2008)
 168 */
 169 void * graphics_get_data(struct graphics *this_, char *type)
 170 {
 171         return (this_->meth.get_data(this_->priv, type));
 172 }
 173
 174 void graphics_add_callback(struct graphics *this_, struct callback *cb)
 175 {
 176         callback_list_add(this_->cbl, cb);
 177 }
 178
 179 void graphics_remove_callback(struct graphics *this_, struct callback *cb)
 180 {
 181         callback_list_remove(this_->cbl, cb);
 182 }
 183
 184 /**
 185  * FIXME
 186  * @param <>
 187  * @returns <>
 188  * @author Martin Schaller (04/2008)
 189 */
 190 struct graphics_font * graphics_font_new(struct graphics *gra, int size, int flags)
 191 {
 192         struct graphics_font *this_;
 193
 194         this_=g_new0(struct graphics_font,1);
 195         this_->priv=gra->meth.font_new(gra->priv, &this_->meth, gra->default_font, size, flags);
 196         return this_;
 197 }
 198
 199 /**
 200  * Free all loaded fonts.
 201  * Used when switching layouts.
 202  * @param gra The graphics instance
 203  * @returns nothing
 204  * @author Sarah Nordstrom (05/2008)
 205  */
 206 void graphics_font_destroy_all(struct graphics *gra)
 207 {
 208         int i;
 209         for(i = 0 ; i < sizeof(gra->font) / sizeof(gra->font[0]); i++) {
 210                 if(!gra->font[i]) continue;
 211                 gra->font[i]->meth.font_destroy(gra->font[i]->priv);
 212                 gra->font[i] = NULL;
 213         }
 214 }
 215
 216 /**
 217  * FIXME
 218  * @param <>
 219  * @returns <>
 220  * @author Martin Schaller (04/2008)
 221 */
 222 struct graphics_gc * graphics_gc_new(struct graphics *gra)
 223 {
 224         struct graphics_gc *this_;
 225
 226         this_=g_new0(struct graphics_gc,1);
 227         this_->priv=gra->meth.gc_new(gra->priv, &this_->meth);
 228         return this_;
 229 }
 230
 231 /**
 232  * FIXME
 233  * @param <>
 234  * @returns <>
 235  * @author Martin Schaller (04/2008)
 236 */
 237 void graphics_gc_destroy(struct graphics_gc *gc)
 238 {
 239         gc->meth.gc_destroy(gc->priv);
 240         g_free(gc);
 241 }
 242
 243 /**
 244  * FIXME
 245  * @param <>
 246  * @returns <>
 247  * @author Martin Schaller (04/2008)
 248 */
 249 void graphics_gc_set_foreground(struct graphics_gc *gc, struct color *c)
 250 {
 251         gc->meth.gc_set_foreground(gc->priv, c);
 252 }
 253
 254 /**
 255  * FIXME
 256  * @param <>
 257  * @returns <>
 258  * @author Martin Schaller (04/2008)
 259 */
 260 void graphics_gc_set_background(struct graphics_gc *gc, struct color *c)
 261 {
 262         gc->meth.gc_set_background(gc->priv, c);
 263 }
 264
 265 /**
 266  * FIXME
 267  * @param <>
 268  * @returns <>
 269  * @author Martin Schaller (04/2008)
 270 */
 271 void graphics_gc_set_linewidth(struct graphics_gc *gc, int width)
 272 {
 273         gc->meth.gc_set_linewidth(gc->priv, width);
 274 }
 275
 276 /**
 277  * FIXME
 278  * @param <>
 279  * @returns <>
 280  * @author Martin Schaller (04/2008)
 281 */
 282 void graphics_gc_set_dashes(struct graphics_gc *gc, int width, int offset, unsigned char dash_list[], int n)
 283 {
 284         if (gc->meth.gc_set_dashes)
 285                 gc->meth.gc_set_dashes(gc->priv, width, offset, dash_list, n);
 286 }
 287
 288 /**
 289  * Create a new image from file path scaled to w and h pixels
 290  * @param gra the graphics instance
 291  * @param path path of the image to load
 292  * @param w width to rescale to
 293  * @param h height to rescale to
 294  * @returns <>
 295  * @author Martin Schaller (04/2008)
 296 */
 297 struct graphics_image * graphics_image_new_scaled(struct graphics *gra, char *path, int w, int h)
 298 {
 299         struct graphics_image *this_;
 300
 301         this_=g_new0(struct graphics_image,1);
 302         this_->height=h;
 303         this_->width=w;
 304         this_->priv=gra->meth.image_new(gra->priv, &this_->meth, path, &this_->width, &this_->height, &this_->hot, 0);
 305         if (! this_->priv) {
 306                 g_free(this_);
 307                 this_=NULL;
 308         }
 309         return this_;
 310 }
 311
 312 /**
 313  * Create a new image from file path scaled to w and h pixels and possibly rotated
 314  * @param gra the graphics instance
 315  * @param path path of the image to load
 316  * @param w width to rescale to
 317  * @param h height to rescale to
 318  * @param rotate angle to rotate the image. Warning, graphics might only support 90 degree steps here
 319  * @returns <>
 320  * @author Martin Schaller (04/2008)
 321 */
 322 struct graphics_image * graphics_image_new_scaled_rotated(struct graphics *gra, char *path, int w, int h, int rotate)
 323 {
 324         struct graphics_image *this_;
 325
 326         this_=g_new0(struct graphics_image,1);
 327         this_->height=h;
 328         this_->width=w;
 329         this_->priv=gra->meth.image_new(gra->priv, &this_->meth, path, &this_->width, &this_->height, &this_->hot, rotate);
 330         if (! this_->priv) {
 331                 g_free(this_);
 332                 this_=NULL;
 333         }
 334         return this_;
 335 }
 336
 337 /**
 338  * Create a new image from file path
 339  * @param gra the graphics instance
 340  * @param path path of the image to load
 341  * @returns <>
 342  * @author Martin Schaller (04/2008)
 343 */
 344 struct graphics_image * graphics_image_new(struct graphics *gra, char *path)
 345 {
 346         return graphics_image_new_scaled(gra, path, -1, -1);
 347 }
 348
 349 /**
 350  * FIXME
 351  * @param <>
 352  * @returns <>
 353  * @author Martin Schaller (04/2008)
 354 */
 355 void graphics_image_free(struct graphics *gra, struct graphics_image *img)
 356 {
 357         if (gra->meth.image_free)
 358                 gra->meth.image_free(gra->priv, img->priv);
 359         g_free(img);
 360 }
 361
 362 /**
 363  * FIXME
 364  * @param <>
 365  * @returns <>
 366  * @author Martin Schaller (04/2008)
 367 */
 368 void graphics_draw_restore(struct graphics *this_, struct point *p, int w, int h)
 369 {
 370         this_->meth.draw_restore(this_->priv, p, w, h);
 371 }
 372
 373 /**
 374  * FIXME
 375  * @param <>
 376  * @returns <>
 377  * @author Martin Schaller (04/2008)
 378 */
 379 void graphics_draw_mode(struct graphics *this_, enum draw_mode_num mode)
 380 {
 381         this_->meth.draw_mode(this_->priv, mode);
 382 }
 383
 384 /**
 385  * FIXME
 386  * @param <>
 387  * @returns <>
 388  * @author Martin Schaller (04/2008)
 389 */
 390 void graphics_draw_lines(struct graphics *this_, struct graphics_gc *gc, struct point *p, int count)
 391 {
 392         this_->meth.draw_lines(this_->priv, gc->priv, p, count);
 393 }
 394
 395 /**
 396  * FIXME
 397  * @param <>
 398  * @returns <>
 399  * @author Martin Schaller (04/2008)
 400 */
 401 void graphics_draw_circle(struct graphics *this_, struct graphics_gc *gc, struct point *p, int r)
 402 {
 403         this_->meth.draw_circle(this_->priv, gc->priv, p, r);
 404 }
 405
 406 /**
 407  * FIXME
 408  * @param <>
 409  * @returns <>
 410  * @author Martin Schaller (04/2008)
 411 */
 412 void graphics_draw_rectangle(struct graphics *this_, struct graphics_gc *gc, struct point *p, int w, int h)
 413 {
 414         this_->meth.draw_rectangle(this_->priv, gc->priv, p, w, h);
 415 }
 416
 417 /**
 418  * FIXME
 419  * @param <>
 420  * @returns <>
 421  * @author Martin Schaller (04/2008)
 422 */
 423 void graphics_draw_text(struct graphics *this_, struct graphics_gc *gc1, struct graphics_gc *gc2, struct graphics_font *font, char *text, struct point *p, int dx, int dy)
 424 {
 425         this_->meth.draw_text(this_->priv, gc1->priv, gc2 ? gc2->priv : NULL, font->priv, text, p, dx, dy);
 426 }
 427
 428 /**
 429  * FIXME
 430  * @param <>
 431  * @returns <>
 432  * @author Martin Schaller (04/2008)
 433 */
 434 void graphics_get_text_bbox(struct graphics *this_, struct graphics_font *font, char *text, int dx, int dy, struct point *ret, int estimate)
 435 {
 436         this_->meth.get_text_bbox(this_->priv, font->priv, text, dx, dy, ret, estimate);
 437 }
 438
 439 /**
 440  * FIXME
 441  * @param <>
 442  * @returns <>
 443  * @author Martin Schaller (04/2008)
 444 */
 445 void graphics_overlay_disable(struct graphics *this_, int disable)
 446 {
 447         if (this_->meth.overlay_disable)
 448                 this_->meth.overlay_disable(this_->priv, disable);
 449 }
 450
 451 /**
 452  * FIXME
 453  * @param <>
 454  * @returns <>
 455  * @author Martin Schaller (04/2008)
 456 */
 457 void graphics_draw_image(struct graphics *this_, struct graphics_gc *gc, struct point *p, struct graphics_image *img)
 458 {
 459         this_->meth.draw_image(this_->priv, gc->priv, p, img->priv);
 460 }
 461
 462
 463 //##############################################################################################################
 464 //# Description:
 465 //# Comment:
 466 //# Authors: Martin Schaller (04/2008)
 467 //##############################################################################################################
 468 int
 469 graphics_draw_drag(struct graphics *this_, struct point *p)
 470 {
 471         if (!this_->meth.draw_drag)
 472                 return 0;
 473         this_->meth.draw_drag(this_->priv, p);
 474         return 1;
 475 }
 476
 477 void
 478 graphics_background_gc(struct graphics *this_, struct graphics_gc *gc)
 479 {
 480         this_->meth.background_gc(this_->priv, gc ? gc->priv : NULL);
 481 }
 482
 483 #include "attr.h"
 484 #include "popup.h"
 485 #include <stdio.h>
 486
 487
 488 #if 0
 489 //##############################################################################################################
 490 //# Description:
 491 //# Comment:
 492 //# Authors: Martin Schaller (04/2008)
 493 //##############################################################################################################
 494 static void popup_view_html(struct popup_item *item, char *file)
 495 {
 496         char command[1024];
 497         sprintf(command,"firefox %s", file);
 498         system(command);
 499 }
 500
 501 struct transformatin *tg;
 502 enum projection pg;
 503
 504 //##############################################################################################################
 505 //# Description:
 506 //# Comment:
 507 //# Authors: Martin Schaller (04/2008)
 508 //##############################################################################################################
 509 static void graphics_popup(struct display_list *list, struct popup_item **popup)
 510 {
 511         struct item *item;
 512         struct attr attr;
 513         struct map_rect *mr;
 514         struct coord c;
 515         struct popup_item *curr_item,*last=NULL;
 516         item=list->data;
 517         mr=map_rect_new(item->map, NULL, NULL, 0);
 518         printf("id hi=0x%x lo=0x%x\n", item->id_hi, item->id_lo);
 519         item=map_rect_get_item_byid(mr, item->id_hi, item->id_lo);
 520         if (item) {
 521                 if (item_attr_get(item, attr_name, &attr)) {
 522                         curr_item=popup_item_new_text(popup,attr.u.str,1);
 523                         if (item_attr_get(item, attr_info_html, &attr)) {
 524                                 popup_item_new_func(&last,"HTML Info",1, popup_view_html, g_strdup(attr.u.str));
 525                         }
 526                         if (item_attr_get(item, attr_price_html, &attr)) {
 527                                 popup_item_new_func(&last,"HTML Preis",2, popup_view_html, g_strdup(attr.u.str));
 528                         }
 529                         curr_item->submenu=last;
 530                 }
 531         }
 532         map_rect_destroy(mr);
 533 }
 534 #endif
 535
 536 /**
 537  * FIXME
 538  * @param <>
 539  * @returns <>
 540  * @author Martin Schaller (04/2008)
 541 */
 542 struct displayitem {
 543         struct item item;
 544         char *label;
 545         int displayed;
 546         int count;
 547         struct coord c[0];
 548 };
 549
 550 /**
 551  * FIXME
 552  * @param <>
 553  * @returns <>
 554  * @author Martin Schaller (04/2008)
 555 */
 556 static int xdisplay_free_list(gpointer key, gpointer value, gpointer user_data)
 557 {
 558         GList *h, *l;
 559         h=value;
 560         l=h;
 561         while (l) {
 562                 struct displayitem *di=l->data;
 563                 if (! di->displayed && di->item.type < type_line)
 564                         dbg(1,"warning: item '%s' not displayed\n", item_to_name(di->item.type));
 565                 g_free(l->data);
 566                 l=g_list_next(l);
 567         }
 568         g_list_free(h);
 569         return TRUE;
 570 }
 571
 572 /**
 573  * FIXME
 574  * @param <>
 575  * @returns <>
 576  * @author Martin Schaller (04/2008)
 577 */
 578 static void xdisplay_free(GHashTable *display_list)
 579 {
 580         g_hash_table_foreach_remove(display_list, xdisplay_free_list, NULL);
 581 }
 582
 583 /**
 584  * FIXME
 585  * @param <>
 586  * @returns <>
 587  * @author Martin Schaller (04/2008)
 588 */
 589 static void display_add(struct displaylist *displaylist, struct item *item, int count, struct coord *c, char *label)
 590 {
 591         struct displayitem *di;
 592         int len;
 593         GList *l;
 594         char *p;
 595
 596         len=sizeof(*di)+count*sizeof(*c);
 597         if (label)
 598                 len+=strlen(label)+1;
 599
 600         p=g_malloc(len);
 601
 602         di=(struct displayitem *)p;
 603         di->displayed=0;
 604         p+=sizeof(*di)+count*sizeof(*c);
 605         di->item=*item;
 606         if (label) {
 607                 di->label=p;
 608                 strcpy(di->label, label);
 609         } else
 610                 di->label=NULL;
 611         di->count=count;
 612         memcpy(di->c, c, count*sizeof(*c));
 613
 614         l=g_hash_table_lookup(displaylist->dl, GINT_TO_POINTER(item->type));
 615         l=g_list_prepend(l, di);
 616         g_hash_table_insert(displaylist->dl, GINT_TO_POINTER(item->type), l);
 617 }
 618
 619
 620 /**
 621  * FIXME
 622  * @param <>
 623  * @returns <>
 624  * @author Martin Schaller (04/2008)
 625 */
 626 static void label_line(struct graphics *gra, struct graphics_gc *fg, struct graphics_gc *bg, struct graphics_font *font, struct point *p, int count, char *label)
 627 {
 628         int i,x,y,tl,tlm,th,thm,tlsq,l;
 629         float lsq;
 630         double dx,dy;
 631         struct point p_t;
 632         struct point pb[5];
 633
 634         if (gra->meth.get_text_bbox) {
 635                 gra->meth.get_text_bbox(gra->priv, font->priv, label, 0x10000, 0x0, pb, 1);
 636                 tl=(pb[2].x-pb[0].x);
 637                 th=(pb[0].y-pb[1].y);
 638         } else {
 639                 tl=strlen(label)*4;
 640                 th=8;
 641         }
 642         tlm=tl*128;
 643         thm=th*144;
 644         tlsq = tlm*tlm;
 645         for (i = 0 ; i < count-1 ; i++) {
 646                 dx=p[i+1].x-p[i].x;
 647                 dx*=128;
 648                 dy=p[i+1].y-p[i].y;
 649                 dy*=128;
 650                 lsq = dx*dx+dy*dy;
 651                 if (lsq > tlsq) {
 652                         l=(int)sqrtf(lsq);
 653                         x=p[i].x;
 654                         y=p[i].y;
 655                         if (dx < 0) {
 656                                 dx=-dx;
 657                                 dy=-dy;
 658                                 x=p[i+1].x;
 659                                 y=p[i+1].y;
 660                         }
 661                         x+=(l-tlm)*dx/l/256;
 662                         y+=(l-tlm)*dy/l/256;
 663                         x-=dy*thm/l/256;
 664                         y+=dx*thm/l/256;
 665                         p_t.x=x;
 666                         p_t.y=y;
 667 #if 0
 668                         dbg(0,"display_text: '%s', %d, %d, %d, %d %d\n", label, x, y, dx*0x10000/l, dy*0x10000/l, l);
 669 #endif
 670                         if (x < gra->r.rl.x && x + tl > gra->r.lu.x && y + tl > gra->r.lu.y && y - tl < gra->r.rl.y)
 671                                 gra->meth.draw_text(gra->priv, fg->priv, bg->priv, font->priv, label, &p_t, dx*0x10000/l, dy*0x10000/l);
 672                 }
 673         }
 674 }
 675
 676 static void display_draw_arrow(struct point *p, int dx, int dy, int l, struct graphics_gc *gc, struct graphics *gra)
 677 {
 678         struct point pnt[3];
 679         pnt[0]=pnt[1]=pnt[2]=*p;
 680         pnt[0].x+=-dx*l/65536+dy*l/65536;
 681         pnt[0].y+=-dy*l/65536-dx*l/65536;
 682         pnt[2].x+=-dx*l/65536-dy*l/65536;
 683         pnt[2].y+=-dy*l/65536+dx*l/65536;
 684         gra->meth.draw_lines(gra->priv, gc->priv, pnt, 3);
 685 }
 686
 687 static void display_draw_arrows(struct graphics *gra, struct graphics_gc *gc, struct point *pnt, int count)
 688 {
 689         int i,dx,dy,l;
 690         struct point p;
 691         for (i = 0 ; i < count-1 ; i++) {
 692                 dx=pnt[i+1].x-pnt[i].x;
 693                 dy=pnt[i+1].y-pnt[i].y;
 694                 l=sqrt(dx*dx+dy*dy);
 695                 if (l) {
 696                         dx=dx*65536/l;
 697                         dy=dy*65536/l;
 698                         p=pnt[i];
 699                         p.x+=dx*15/65536;
 700                         p.y+=dy*15/65536;
 701                         display_draw_arrow(&p, dx, dy, 10, gc, gra);
 702                         p=pnt[i+1];
 703                         p.x-=dx*15/65536;
 704                         p.y-=dy*15/65536;
 705                         display_draw_arrow(&p, dx, dy, 10, gc, gra);
 706                 }
 707         }
 708 }
 709
 710 static int
 711 intersection(struct point * a1, int adx, int ady, struct point * b1, int bdx, int bdy,
 712               struct point * res)
 713 {
 714         int n, a, b;
 715         n = bdy * adx - bdx * ady;
 716         a = bdx * (a1->y - b1->y) - bdy * (a1->x - b1->x);
 717         b = adx * (a1->y - b1->y) - ady * (a1->x - b1->x);
 718         if (n < 0) {
 719                 n = -n;
 720                 a = -a;
 721                 b = -b;
 722         }
 723 #if 0
 724         if (a < 0 || b < 0)
 725                 return 0;
 726         if (a > n || b > n)
 727                 return 0;
 728 #endif
 729         if (n == 0)
 730                 return 0;
 731         res->x = a1->x + a * adx / n;
 732         res->y = a1->y + a * ady / n;
 733         return 1;
 734 }
 735
 736 struct circle {
 737         int x,y,fowler;
 738 } lw10[]={
 739 {0,10,0},
 740 {4,9,56},
 741 {7,7,128},
 742 {9,4,200},
 743 {10,0,256},
 744 {9,-4,312},
 745 {7,-7,384},
 746 {4,-9,456},
 747 {0,-10,512},
 748 {-4,-9,568},
 749 {-7,-7,640},
 750 {-9,-4,712},
 751 {-10,0,768},
 752 {-9,4,824},
 753 {-7,7,896},
 754 {-4,9,968},
 755 };
 756
 757 static void
 758 draw_circle(struct point *pnt, int diameter, int scale, int start, int len, struct point *res, int *pos, int dir)
 759 {
 760         struct circle *c;
 761
 762 #if 0
 763         dbg(0,"diameter=%d start=%d len=%d pos=%d dir=%d\n", diameter, start, len, *pos, dir);
 764 #endif
 765         int end=start+len;
 766         int i;
 767         c=lw10;
 768         if (len > 0) {
 769                 while (start < 0) {
 770                         start+=1024;
 771                         end+=1024;
 772                 }
 773                 while (end > 0) {
 774                         i=0;
 775                         while (i < 16 && c[i].fowler <= start)
 776                                 i++;
 777                         while (i < 16 && c[i].fowler < end) {
 778                                 res[*pos].x=pnt->x+c[i].x*diameter/20;
 779                                 res[*pos].y=pnt->y+c[i].y*diameter/20;
 780                                 (*pos)+=dir;
 781                                 i++;
 782                         }
 783                         end-=1024;
 784                         start-=1024;
 785                 }
 786         } else {
 787                 while (start > 1024) {
 788                         start-=1024;
 789                         end-=1024;
 790                 }
 791                 while (end < 1024) {
 792                         i=15;
 793                         while (i >= 0 && c[i].fowler >= end)
 794                                 i--;
 795                         while (i >= 0 && c[i].fowler > start) {
 796                                 res[*pos].x=pnt->x+c[i].x*diameter/20;
 797                                 res[*pos].y=pnt->y+c[i].y*diameter/20;
 798                                 (*pos)+=dir;
 799                                 i--;
 800                         }
 801                         start+=1024;
 802                         end+=1024;
 803                 }
 804         }
 805 }
 806
 807
 808 static int
 809 fowler(int dy, int dx)
 810 {
 811         int adx, ady;           /* Absolute Values of Dx and Dy */
 812         int code;               /* Angular Region Classification Code */
 813
 814         adx = (dx < 0) ? -dx : dx;      /* Compute the absolute values. */
 815         ady = (dy < 0) ? -dy : dy;
 816
 817         code = (adx < ady) ? 1 : 0;
 818         if (dx < 0)
 819                 code += 2;
 820         if (dy < 0)
 821                 code += 4;
 822
 823         switch (code) {
 824         case 0:
 825                 return (dx == 0) ? 0 : 128*ady / adx;   /* [  0, 45] */
 826         case 1:
 827                 return (256 - (128*adx / ady)); /* ( 45, 90] */
 828         case 3:
 829                 return (256 + (128*adx / ady)); /* ( 90,135) */
 830         case 2:
 831                 return (512 - (128*ady / adx)); /* [135,180] */
 832         case 6:
 833                 return (512 + (128*ady / adx)); /* (180,225] */
 834         case 7:
 835                 return (768 - (128*adx / ady)); /* (225,270) */
 836         case 5:
 837                 return (768 + (128*adx / ady)); /* [270,315) */
 838         case 4:
 839                 return (1024 - (128*ady / adx));/* [315,360) */
 840         }
 841         return 0;
 842 }
 843 static int
 844 int_sqrt(unsigned int n)
 845 {
 846         unsigned int h, p= 0, q= 1, r= n;
 847         while ( q <= n )
 848                 q <<= 2;
 849         while ( q != 1 ) {
 850                 q >>= 2;
 851                 h = p + q;
 852                 p >>= 1;
 853                 if ( r >= h ) {
 854                         p += q;
 855                         r -= h;
 856                 }
 857         }
 858         return p;
 859 }
 860
 861 struct offset {
 862         int px,py,nx,ny;
 863 };
 864
 865 static void
 866 calc_offsets(int wi, int l, int dx, int dy, struct offset *res)
 867 {
 868         int x,y;
 869         x = (dx * wi) / l;
 870         y = (dy * wi) / l;
 871         if (x < 0) {
 872                 res->nx = -x/2;
 873                 res->px = (x-1)/2;
 874         } else {
 875                 res->nx = -(x+1)/2;
 876                 res->px = x/2;
 877         }
 878         if (y < 0) {
 879                 res->ny = -y/2;
 880                 res->py = (y-1)/2;
 881         } else {
 882                 res->ny = -(y+1)/2;
 883                 res->py = y/2;
 884         }
 885 }
 886
 887 static void
 888 graphics_draw_polyline_as_polygon(struct graphics *gra, struct graphics_gc *gc, struct point *pnt, int count, int *width, int step)
 889 {
 890         int maxpoints=200;
 891         struct point res[maxpoints], pos, poso, neg, nego;
 892         int i, dx=0, dy=0, l=0, dxo=0, dyo=0;
 893         struct offset o,oo;
 894         int fow=0, fowo=0, delta;
 895         int wi, ppos = maxpoints/2, npos = maxpoints/2;
 896         int state,prec=5;
 897         int max_circle_points=20;
 898         for (i = 0; i < count; i++) {
 899                 wi=*width;
 900                 width+=step;
 901                 if (i < count - 1) {
 902                         dx = (pnt[i + 1].x - pnt[i].x);
 903                         dy = (pnt[i + 1].y - pnt[i].y);
 904                         l = int_sqrt(dx * dx + dy * dy);
 905                         fow=fowler(-dy, dx);
 906                 }
 907                 if (! l)
 908                         l=1;
 909                 calc_offsets(wi, l, dx, dy, &o);
 910                 pos.x = pnt[i].x + o.ny;
 911                 pos.y = pnt[i].y + o.px;
 912                 neg.x = pnt[i].x + o.py;
 913                 neg.y = pnt[i].y + o.nx;
 914                 if (! i)
 915                         state=0;
 916                 else if (i == count-1)
 917                         state=2;
 918                 else if (npos < max_circle_points || ppos >= maxpoints-max_circle_points)
 919                         state=3;
 920                 else
 921                         state=1;
 922                 switch (state) {
 923                 case 1:
 924                        if (fowo != fow) {
 925                                 poso.x = pnt[i].x + oo.ny;
 926                                 poso.y = pnt[i].y + oo.px;
 927                                 nego.x = pnt[i].x + oo.py;
 928                                 nego.y = pnt[i].y + oo.nx;
 929                                 delta=fowo-fow;
 930                                 if (delta < 0)
 931                                         delta+=1024;
 932                                 if (delta < 512) {
 933                                         if (intersection(&pos, dx, dy, &poso, dxo, dyo, &res[ppos]))
 934                                                 ppos++;
 935                                         res[--npos] = nego;
 936                                         --npos;
 937                                         draw_circle(&pnt[i], wi, prec, fowo-512, -delta, res, &npos, -1);
 938                                         res[npos] = neg;
 939                                 } else {
 940                                         res[ppos++] = poso;
 941                                         draw_circle(&pnt[i], wi, prec, fowo, 1024-delta, res, &ppos, 1);
 942                                         res[ppos++] = pos;
 943                                         if (intersection(&neg, dx, dy, &nego, dxo, dyo, &res[npos - 1]))
 944                                                 npos--;
 945                                 }
 946                         }
 947                         break;
 948                 case 2:
 949                 case 3:
 950                         res[--npos] = neg;
 951                         --npos;
 952                         draw_circle(&pnt[i], wi, prec, fow-512, -512, res, &npos, -1);
 953                         res[npos] = pos;
 954                         res[ppos++] = pos;
 955                         dbg_assert(npos > 0);
 956                         dbg_assert(ppos < maxpoints);
 957                         gra->meth.draw_polygon(gra->priv, gc->priv, res+npos, ppos-npos);
 958                         if (state == 2)
 959                                 break;
 960                         npos=maxpoints/2;
 961                         ppos=maxpoints/2;
 962                 case 0:
 963                         res[ppos++] = neg;
 964                         draw_circle(&pnt[i], wi, prec, fow+512, 512, res, &ppos, 1);
 965                         res[ppos++] = pos;
 966                         break;
 967                 }
 968                 if (step) {
 969                         wi=*width;
 970                         calc_offsets(wi, l, dx, dy, &oo);
 971                 } else
 972                         oo=o;
 973                 dxo = -dx;
 974                 dyo = -dy;
 975                 fowo=fow;
 976         }
 977 }
 978
 979 struct transformation *tg;
 980 enum projection pg;
 981
 982 struct wpoint {
 983         int x,y,w;
 984 };
 985
 986 static int
 987 clipcode(struct wpoint *p, struct point_rect *r)
 988 {
 989         int code=0;
 990         if (p->x < r->lu.x)
 991                 code=1;
 992         if (p->x > r->rl.x)
 993                 code=2;
 994         if (p->y < r->lu.y)
 995                 code |=4;
 996         if (p->y > r->rl.y)
 997                 code |=8;
 998         return code;
 999 }
1000
1001
1002 static int
1003 clip_line(struct wpoint *p1, struct wpoint *p2, struct point_rect *r)
1004 {
1005         int code1,code2,ret=1;
1006         int dx,dy,dw;
1007         code1=clipcode(p1, r);
1008         if (code1)
1009                 ret |= 2;
1010         code2=clipcode(p2, r);
1011         if (code2)
1012                 ret |= 4;
1013         dx=p2->x-p1->x;
1014         dy=p2->y-p1->y;
1015         dw=p2->w-p1->w;
1016         while (code1 || code2) {
1017                 if (code1 & code2)
1018                         return 0;
1019                 if (code1 & 1) {
1020                         p1->y+=(r->lu.x-p1->x)*dy/dx;
1021                         p1->w+=(r->lu.x-p1->x)*dw/dx;
1022                         p1->x=r->lu.x;
1023                 } else if (code1 & 2) {
1024                         p1->y+=(r->rl.x-p1->x)*dy/dx;
1025                         p1->w+=(r->rl.x-p1->x)*dw/dx;
1026                         p1->x=r->rl.x;
1027                 } else if (code1 & 4) {
1028                         p1->x+=(r->lu.y-p1->y)*dx/dy;
1029                         p1->w+=(r->lu.y-p1->y)*dw/dy;
1030                         p1->y=r->lu.y;
1031                 } else if (code1 & 8) {
1032                         p1->x+=(r->rl.y-p1->y)*dx/dy;
1033                         p1->w+=(r->rl.y-p1->y)*dw/dy;
1034                         p1->y=r->rl.y;
1035                 }
1036                 code1=clipcode(p1, r);
1037                 if (code1 & code2)
1038                         return 0;
1039                 if (code2 & 1) {
1040                         p2->y+=(r->lu.x-p2->x)*dy/dx;
1041                         p2->w+=(r->lu.x-p2->x)*dw/dx;
1042                         p2->x=r->lu.x;
1043                 } else if (code2 & 2) {
1044                         p2->y+=(r->rl.x-p2->x)*dy/dx;
1045                         p2->w+=(r->rl.x-p2->x)*dw/dx;
1046                         p2->x=r->rl.x;
1047                 } else if (code2 & 4) {
1048                         p2->x+=(r->lu.y-p2->y)*dx/dy;
1049                         p2->w+=(r->lu.y-p2->y)*dw/dy;
1050                         p2->y=r->lu.y;
1051                 } else if (code2 & 8) {
1052                         p2->x+=(r->rl.y-p2->y)*dx/dy;
1053                         p2->w+=(r->rl.y-p2->y)*dw/dy;
1054                         p2->y=r->rl.y;
1055                 }
1056                 code2=clipcode(p2, r);
1057         }
1058         return ret;
1059 }
1060
1061 static void
1062 graphics_draw_polyline_clipped(struct graphics *gra, struct graphics_gc *gc, struct point *pa, int count, int *width, int step, int poly)
1063 {
1064         struct point p[count+1];
1065         int w[count*step+1];
1066         struct wpoint p1,p2;
1067         int i,code,out=0;
1068         int wmax;
1069         struct point_rect r=gra->r;
1070
1071         wmax=width[0];
1072         if (step) {
1073                 for (i = 1 ; i < count ; i++) {
1074                         if (width[i*step] > wmax)
1075                                 wmax=width[i*step];
1076                 }
1077         }
1078         if (wmax <= 0)
1079                 return;
1080         r.lu.x-=wmax;
1081         r.lu.y-=wmax;
1082         r.rl.x+=wmax;
1083         r.rl.y+=wmax;
1084         for (i = 0 ; i < count ; i++) {
1085                 if (i) {
1086                         p1.x=pa[i-1].x;
1087                         p1.y=pa[i-1].y;
1088                         p1.w=width[(i-1)*step];
1089                         p2.x=pa[i].x;
1090                         p2.y=pa[i].y;
1091                         p2.w=width[i*step];
1092                         /* 0 = invisible, 1 = completely visible, 3 = start point clipped, 5 = end point clipped, 7 both points clipped */
1093                         code=clip_line(&p1, &p2, &r);
1094                         if (((code == 1 || code == 5) && i == 1) || (code & 2)) {
1095                                 p[out].x=p1.x;
1096                                 p[out].y=p1.y;
1097                                 w[out*step]=p1.w;
1098                                 out++;
1099                         }
1100                         if (code) {
1101                                 p[out].x=p2.x;
1102                                 p[out].y=p2.y;
1103                                 w[out*step]=p2.w;
1104                                 out++;
1105                         }
1106                         if (i == count-1 || (code & 4)) {
1107                                 if (out > 1) {
1108                                         if (poly) {
1109                                                 graphics_draw_polyline_as_polygon(gra, gc, p, out, w, step);
1110                                         } else
1111                                                 gra->meth.draw_lines(gra->priv, gc->priv, p, out);
1112                                         out=0;
1113                                 }
1114                         }
1115                 }
1116         }
1117 }
1118
1119 static int
1120 is_inside(struct point *p, struct point_rect *r, int edge)
1121 {
1122         switch(edge) {
1123         case 0:
1124                 return p->x >= r->lu.x;
1125         case 1:
1126                 return p->x <= r->rl.x;
1127         case 2:
1128                 return p->y >= r->lu.y;
1129         case 3:
1130                 return p->y <= r->rl.y;
1131         default:
1132                 return 0;
1133         }
1134 }
1135
1136 static void
1137 poly_intersection(struct point *p1, struct point *p2, struct point_rect *r, int edge, struct point *ret)
1138 {
1139         int dx=p2->x-p1->x;
1140         int dy=p2->y-p1->y;
1141         switch(edge) {
1142         case 0:
1143                 ret->y=p1->y+(r->lu.x-p1->x)*dy/dx;
1144                 ret->x=r->lu.x;
1145                 break;
1146         case 1:
1147                 ret->y=p1->y+(r->rl.x-p1->x)*dy/dx;
1148                 ret->x=r->rl.x;
1149                 break;
1150         case 2:
1151                 ret->x=p1->x+(r->lu.y-p1->y)*dx/dy;
1152                 ret->y=r->lu.y;
1153                 break;
1154         case 3:
1155                 ret->x=p1->x+(r->rl.y-p1->y)*dx/dy;
1156                 ret->y=r->rl.y;
1157                 break;
1158         }
1159 }
1160
1161 static void
1162 graphics_draw_polygon_clipped(struct graphics *gra, struct graphics_gc *gc, struct point *pin, int count_in)
1163 {
1164         struct point_rect r=gra->r;
1165         struct point *pout,*p,*s,pi;
1166         struct point p1[count_in+1];
1167         struct point p2[count_in+1];
1168         int count_out,edge=3;
1169         int i;
1170 #if 0
1171         r.lu.x+=20;
1172         r.lu.y+=20;
1173         r.rl.x-=20;
1174         r.rl.y-=20;
1175 #endif
1176
1177         pout=p1;
1178         for (edge = 0 ; edge < 4 ; edge++) {
1179                 p=pin;
1180                 s=pin+count_in-1;
1181                 count_out=0;
1182                 for (i = 0 ; i < count_in ; i++) {
1183                         if (is_inside(p, &r, edge)) {
1184                                 if (! is_inside(s, &r, edge)) {
1185                                         poly_intersection(s,p,&r,edge,&pi);
1186                                         pout[count_out++]=pi;
1187                                 }
1188                                 pout[count_out++]=*p;
1189                         } else {
1190                                 if (is_inside(s, &r, edge)) {
1191                                         poly_intersection(p,s,&r,edge,&pi);
1192                                         pout[count_out++]=pi;
1193                                 }
1194                         }
1195                         s=p;
1196                         p++;
1197                 }
1198                 count_in=count_out;
1199                 if (pin == p1) {
1200                         pin=p2;
1201                         pout=p1;
1202                 } else {
1203                         pin=p1;
1204                         pout=p2;
1205                 }
1206         }
1207         gra->meth.draw_polygon(gra->priv, gc->priv, pin, count_in);
1208 }
1209
1210
1211
1212 /**
1213  * FIXME
1214  * @param <>
1215  * @returns <>
1216  * @author Martin Schaller (04/2008)
1217 */
1218 static void xdisplay_draw_elements(struct graphics *gra, GHashTable *display_list, struct itemgra *itm)
1219 {
1220         struct element *e;
1221         GList *l,*ls,*es,*types;
1222         enum item_type type;
1223         struct graphics_gc *gc = NULL;
1224         struct graphics_image *img=NULL;
1225         struct point p;
1226         char path[PATH_MAX];
1227         struct point pa[16384];
1228         int width[16384];
1229         int count;
1230
1231         es=itm->elements;
1232         while (es) {
1233                 e=es->data;
1234                 types=itm->type;
1235                 while (types) {
1236                         type=GPOINTER_TO_INT(types->data);
1237                         ls=g_hash_table_lookup(display_list, GINT_TO_POINTER(type));
1238                         l=ls;
1239                         if (gc)
1240                                 graphics_gc_destroy(gc);
1241                         if (img)
1242                                 graphics_image_free(gra, img);
1243                         gc=NULL;
1244                         img=NULL;
1245                         while (l) {
1246                                 struct displayitem *di;
1247                                 di=l->data;
1248                                 di->displayed=1;
1249                                 if (! gc) {
1250                                         gc=graphics_gc_new(gra);
1251                                         gc->meth.gc_set_foreground(gc->priv, &e->color);
1252                                 }
1253                                 if (e->type == element_polyline) {
1254                                         count=transform(tg, pg, di->c, pa, di->count, 1, e->u.polyline.width, width);
1255                                 }
1256                                 else
1257                                         count=transform(tg, pg, di->c, pa, di->count, 1, 0, NULL);
1258                                 switch (e->type) {
1259                                 case element_polygon:
1260 #if 0
1261                                         {
1262                                                 int i;
1263                                                 for (i = 0 ; i < count ; i++) {
1264                                                         dbg(0,"pa[%d]=%d,%d\n", i, pa[i].x, pa[i].y);
1265                                                 }
1266                                         }
1267                                         dbg(0,"element_polygon count=%d\n",count);
1268 #endif
1269 #if 1
1270                                         graphics_draw_polygon_clipped(gra, gc, pa, count);
1271 #endif
1272                                         break;
1273                                 case element_polyline:
1274 #if 0
1275                                         if (e->u.polyline.width > 1) {
1276                                                 graphics_draw_polyline_as_polygon(gra, gc, pa, count, width, 0);
1277                                         } else {
1278 #else
1279                                         {
1280                                                  if (e->u.polyline.width > 1)
1281                                                              gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
1282
1283
1284 #endif
1285                                                 if (e->u.polyline.width > 0 && e->u.polyline.dash_num > 0)
1286                                                         graphics_gc_set_dashes(gc, e->u.polyline.width,
1287                                                                                e->u.polyline.offset,
1288                                                                                e->u.polyline.dash_table,
1289                                                                                e->u.polyline.dash_num);
1290 #if 0
1291                                                 if (di->label && !strcmp(di->label, "Bahnhofstr.") && di->item.type != type_street_1_city) {
1292                                                         dbg(0,"0x%x,0x%x %s\n", di->item.id_hi, di->item.id_lo, item_to_name(di->item.type));
1293 #endif
1294                                                 graphics_draw_polyline_clipped(gra, gc, pa, count, width, 1, e->u.polyline.width > 1);
1295 #if 0
1296                                                 }
1297 #endif
1298                                         }
1299                                         break;
1300                                 case element_circle:
1301                                         if (count) {
1302                                                 if (e->u.circle.width > 1)
1303                                                         gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
1304                                                 gra->meth.draw_circle(gra->priv, gc->priv, pa, e->u.circle.radius);
1305                                                 if (di->label && e->text_size) {
1306                                                         p.x=pa[0].x+3;
1307                                                         p.y=pa[0].y+10;
1308                                                         if (! gra->font[e->text_size])
1309                                                                 gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
1310                                                         gra->meth.draw_text(gra->priv, gra->gc[2]->priv, gra->gc[1]->priv, gra->font[e->text_size]->priv, di->label, &p, 0x10000, 0);
1311                                                 }
1312                                         }
1313                                         break;
1314                                 case element_text:
1315                                         if (count && di->label) {
1316                                                 if (! gra->font[e->text_size])
1317                                                         gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
1318                                                 label_line(gra, gra->gc[2], gra->gc[1], gra->font[e->text_size], pa, count, di->label);
1319                                         }
1320                                         break;
1321                                 case element_icon:
1322                                         if (count) {
1323                                                 if (!img) {
1324                                                         if (e->u.icon.src[0] == '/')
1325                                                                 strcpy(path,e->u.icon.src);
1326                                                         else
1327                                                                 sprintf(path,"%s/xpm/%s", navit_sharedir, e->u.icon.src);
1328                                                         img=graphics_image_new_scaled_rotated(gra, path, e->u.icon.width, e->u.icon.height, e->u.icon.rotation);
1329                                                         if (! img)
1330                                                                 dbg(0,"failed to load icon '%s'\n", e->u.icon.src);
1331                                                 }
1332                                                 if (img) {
1333                                                         p.x=pa[0].x - img->hot.x;
1334                                                         p.y=pa[0].y - img->hot.y;
1335                                                         gra->meth.draw_image(gra->priv, gra->gc[0]->priv, &p, img->priv);
1336                                                 }
1337                                         }
1338                                         break;
1339                                 case element_image:
1340                                         dbg(1,"image: '%s'\n", di->label);
1341                                         if (gra->meth.draw_image_warp)
1342                                                 gra->meth.draw_image_warp(gra->priv, gra->gc[0]->priv, pa, count, di->label);
1343                                         else
1344                                                 dbg(0,"draw_image_warp not supported by graphics driver drawing '%s'\n", di->label);
1345                                         break;
1346                                 case element_arrows:
1347                                         display_draw_arrows(gra,gc,pa,count);
1348                                         break;
1349                                 default:
1350                                         printf("Unhandled element type %d\n", e->type);
1351
1352                                 }
1353                                 l=g_list_next(l);
1354                         }
1355                         types=g_list_next(types);
1356                 }
1357                 es=g_list_next(es);
1358         }
1359         if (gc)
1360                 graphics_gc_destroy(gc);
1361         if (img)
1362                 graphics_image_free(gra, img);
1363 }
1364
1365 void
1366 graphics_draw_itemgra(struct graphics *gra, struct itemgra *itm, struct transformation *t)
1367 {
1368         GList *es;
1369         struct point p;
1370         struct coord c;
1371         char *label=NULL;
1372         struct graphics_gc *gc = NULL;
1373         struct graphics_image *img;
1374         char path[PATH_MAX];
1375         es=itm->elements;
1376         c.x=0;
1377         c.y=0;
1378         while (es) {
1379                 struct element *e=es->data;
1380                 int count=e->coord_count;
1381                 struct point pnt[count+1];
1382                 if (count)
1383                         transform(t, projection_screen, e->coord, pnt, count, 0, 0, NULL);
1384                 else {
1385                         transform(t, projection_screen, &c, pnt, 1, 0, 0, NULL);
1386                         count=1;
1387                 }
1388                 gc=graphics_gc_new(gra);
1389                 gc->meth.gc_set_foreground(gc->priv, &e->color);
1390                 switch (e->type) {
1391                 case element_polyline:
1392                         if (e->u.polyline.width > 1)
1393                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
1394                         if (e->u.polyline.width > 0 && e->u.polyline.dash_num > 0)
1395                                 graphics_gc_set_dashes(gc, e->u.polyline.width,
1396                                                        e->u.polyline.offset,
1397                                                        e->u.polyline.dash_table,
1398                                                        e->u.polyline.dash_num);
1399                         gra->meth.draw_lines(gra->priv, gc->priv, pnt, count);
1400                         break;
1401                 case element_circle:
1402                         if (e->u.circle.width > 1)
1403                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
1404                         gra->meth.draw_circle(gra->priv, gc->priv, &pnt[0], e->u.circle.radius);
1405                         if (label && e->text_size) {
1406                                 p.x=pnt[0].x+3;
1407                                 p.y=pnt[0].y+10;
1408                         if (! gra->font[e->text_size])
1409                                 gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
1410                                 gra->meth.draw_text(gra->priv, gra->gc[2]->priv, gra->gc[1]->priv, gra->font[e->text_size]->priv, label, &p, 0x10000, 0);
1411                         }
1412                         break;
1413                 case element_icon:
1414                         if (e->u.icon.src[0] == '/')
1415                                 strcpy(path,e->u.icon.src);
1416                         else
1417                                 sprintf(path,"%s/xpm/%s", navit_sharedir, e->u.icon.src);
1418                         img=graphics_image_new_scaled_rotated(gra, path, e->u.icon.width, e->u.icon.height, e->u.icon.rotation);
1419                         if (! img)
1420                                 dbg(0,"failed to load icon '%s'\n", e->u.icon.src);
1421                         else {
1422                                 p.x=pnt[0].x - img->hot.x;
1423                                 p.y=pnt[0].y - img->hot.y;
1424                                 gra->meth.draw_image(gra->priv, gc->priv, &p, img->priv);
1425                                 graphics_image_free(gra, img);
1426                         }
1427                         break;
1428                 default:
1429                         dbg(0,"dont know how to draw %d\n", e->type);
1430                 }
1431                 graphics_gc_destroy(gc);
1432                 es=g_list_next(es);
1433         }
1434 }
1435
1436 /**
1437  * FIXME
1438  * @param <>
1439  * @returns <>
1440  * @author Martin Schaller (04/2008)
1441 */
1442 static void xdisplay_draw_layer(GHashTable *display_list, struct graphics *gra, struct layer *lay, int order)
1443 {
1444         GList *itms;
1445         struct itemgra *itm;
1446
1447         itms=lay->itemgras;
1448         while (itms) {
1449                 itm=itms->data;
1450                 if (order >= itm->order.min && order <= itm->order.max)
1451                         xdisplay_draw_elements(gra, display_list, itm);
1452                 itms=g_list_next(itms);
1453         }
1454 }
1455
1456 /**
1457  * FIXME
1458  * @param <>
1459  * @returns <>
1460  * @author Martin Schaller (04/2008)
1461 */
1462 static void xdisplay_draw(GHashTable *display_list, struct graphics *gra, struct layout *l, int order)
1463 {
1464         GList *lays;
1465         struct layer *lay;
1466
1467         lays=l->layers;
1468         while (lays) {
1469                 lay=lays->data;
1470                 xdisplay_draw_layer(display_list, gra, lay, order);
1471                 lays=g_list_next(lays);
1472         }
1473 }
1474
1475 /**
1476  * FIXME
1477  * @param <>
1478  * @returns <>
1479  * @author Martin Schaller (04/2008)
1480 */
1481 extern void *route_selection;
1482
1483 /**
1484  * FIXME
1485  * @param <>
1486  * @returns <>
1487  * @author Martin Schaller (04/2008)
1488 */
1489 static void do_draw_map(struct displaylist *displaylist, struct transformation *t, struct map *m, int order)
1490 {
1491         enum projection pro;
1492         struct map_rect *mr;
1493         struct item *item;
1494         int conv,count,max=16384;
1495         struct coord ca[max];
1496         struct attr attr;
1497         struct map_selection *sel;
1498         struct coord_rect r;
1499
1500         pro=map_projection(m);
1501         conv=map_requires_conversion(m);
1502         sel=transform_get_selection(t, pro, order);
1503         tg=t;
1504         pg=pro;
1505 #if 0
1506         sel=NULL;
1507 #endif
1508         if (route_selection)
1509                 mr=map_rect_new(m, route_selection);
1510         else
1511                 mr=map_rect_new(m, sel);
1512         if (! mr) {
1513                 map_selection_destroy(sel);
1514                 return;
1515         }
1516         while ((item=map_rect_get_item(mr))) {
1517 #if 0
1518                 if (num < 7599 || num > 7599)
1519                         continue;
1520 #endif
1521 #if 0
1522                 if (item->id_hi != 0xb0031 || item->id_lo != 0x20c9aeea)
1523                         continue;
1524 #endif
1525                 count=item_coord_get_with_bbox(item, ca, item->type < type_line ? 1: max, &r);
1526                 if (item->type >= type_line && count < 2) {
1527                         dbg(1,"poly from map has only %d points\n", count);
1528                         continue;
1529                 }
1530                 if (! map_selection_contains_rect(sel, &r))
1531                         continue;
1532                 if (item->type < type_line) {
1533 #if 0
1534                         if (! map_selection_contains_point(sel, &ca[0])) {
1535                                 dbg(1,"point not visible\n");
1536                                 continue;
1537                         }
1538 #endif
1539                 } else if (item->type < type_area) {
1540 #if 0
1541                         if (! map_selection_contains_polyline(sel, ca, count)) {
1542                                 dbg(1,"polyline not visible\n");
1543                                 continue;
1544                         }
1545 #endif
1546                 } else {
1547 #if 0
1548                         if (! map_selection_contains_polygon(sel, ca, count)) {
1549                                 dbg(1,"polygon not visible\n");
1550                                 continue;
1551                         }
1552 #endif
1553                 }
1554                 if (count == max)
1555                         dbg(0,"point count overflow\n", count);
1556                 if (!item_attr_get(item, attr_label, &attr))
1557                         attr.u.str=NULL;
1558                 if (conv && attr.u.str && attr.u.str[0]) {
1559                         char *str=map_convert_string(m, attr.u.str);
1560                         display_add(displaylist, item, count, ca, str);
1561                         map_convert_free(str);
1562                 } else
1563                         display_add(displaylist, item, count, ca, attr.u.str);
1564         }
1565         map_rect_destroy(mr);
1566         map_selection_destroy(sel);
1567 }
1568
1569 /**
1570  * FIXME
1571  * @param <>
1572  * @returns <>
1573  * @author Martin Schaller (04/2008)
1574 */
1575 static void do_draw(struct displaylist *displaylist, struct transformation *t, GList *mapsets, int order)
1576 {
1577         struct mapset *ms;
1578         struct map *m;
1579         struct mapset_handle *h;
1580
1581         if (! mapsets)
1582                 return;
1583         ms=mapsets->data;
1584         h=mapset_open(ms);
1585         while ((m=mapset_next(h, 1))) {
1586                 do_draw_map(displaylist, t, m, order);
1587         }
1588         mapset_close(h);
1589 }
1590
1591 /**
1592  * FIXME
1593  * @param <>
1594  * @returns <>
1595  * @author Martin Schaller (04/2008)
1596 */
1597 int graphics_ready(struct graphics *this_)
1598 {
1599         return this_->ready;
1600 }
1601
1602 /**
1603  * FIXME
1604  * @param <>
1605  * @returns <>
1606  * @author Martin Schaller (04/2008)
1607 */
1608 void graphics_displaylist_draw(struct graphics *gra, struct displaylist *displaylist, struct transformation *trans, struct layout *l, int callback)
1609 {
1610         int order=transform_get_order(trans);
1611         struct point p;
1612         tg=trans;
1613         p.x=0;
1614         p.y=0;
1615         // FIXME find a better place to set the background color
1616         if (l) {
1617                 graphics_gc_set_background(gra->gc[0], &l->color);
1618                 graphics_gc_set_foreground(gra->gc[0], &l->color);
1619                 gra->default_font = g_strdup(l->font);
1620         }
1621         graphics_background_gc(gra, gra->gc[0]);
1622         gra->meth.draw_mode(gra->priv, draw_mode_begin);
1623         gra->meth.draw_rectangle(gra->priv, gra->gc[0]->priv, &p, 32767, 32767);
1624         if (l)
1625                 xdisplay_draw(displaylist->dl, gra, l, order+l->order_delta);
1626         if (callback)
1627                 callback_list_call_attr_0(gra->cbl, attr_postdraw);
1628         gra->meth.draw_mode(gra->priv, draw_mode_end);
1629 }
1630
1631 #if 0
1632 /**
1633  * FIXME
1634  * @param <>
1635  * @returns <>
1636  * @author Martin Schaller (04/2008)
1637 */
1638 void graphics_displaylist_move(struct displaylist *displaylist, int dx, int dy)
1639 {
1640         struct displaylist_handle *dlh;
1641         struct displayitem *di;
1642         int i;
1643
1644         dlh=graphics_displaylist_open(displaylist);
1645         while ((di=graphics_displaylist_next(dlh))) {
1646                 for (i = 0 ; i < di->count ; i++) {
1647                         di->pnt[i].x+=dx;
1648                         di->pnt[i].y+=dy;
1649                 }
1650         }
1651         graphics_displaylist_close(dlh);
1652 }
1653 #endif
1654
1655 /**
1656  * FIXME
1657  * @param <>
1658  * @returns <>
1659  * @author Martin Schaller (04/2008)
1660 */
1661 void graphics_draw(struct graphics *gra, struct displaylist *displaylist, GList *mapsets, struct transformation *trans, struct layout *l)
1662 {
1663         int order=transform_get_order(trans);
1664
1665         dbg(1,"enter");
1666
1667 #if 0
1668         printf("scale=%d center=0x%x,0x%x mercator scale=%f\n", scale, co->trans->center.x, co->trans->center.y, transform_scale(co->trans->center.y));
1669 #endif
1670
1671         xdisplay_free(displaylist->dl);
1672         dbg(1,"order=%d\n", order);
1673
1674
1675 #if 0
1676         for (i = 0 ; i < data_window_type_end; i++) {
1677                 data_window_begin(co->data_window[i]);
1678         }
1679 #endif
1680         profile(0,NULL);
1681         if (l)
1682                 order+=l->order_delta;
1683         if (mapsets)
1684                 do_draw(displaylist, trans, mapsets, order);
1685 //      profile(1,"do_draw");
1686         graphics_displaylist_draw(gra, displaylist, trans, l, 1);
1687         profile(1,"xdisplay_draw");
1688         profile(0,"end");
1689
1690 #if 0
1691         for (i = 0 ; i < data_window_type_end; i++) {
1692                 data_window_end(co->data_window[i]);
1693         }
1694 #endif
1695         gra->ready=1;
1696 }
1697
1698 /**
1699  * FIXME
1700  * @param <>
1701  * @returns <>
1702  * @author Martin Schaller (04/2008)
1703 */
1704 struct displaylist_handle {
1705         GList *hl_head,*hl,*l;
1706 };
1707
1708 /**
1709  * FIXME
1710  * @param <>
1711  * @returns <>
1712  * @author Martin Schaller (04/2008)
1713 */
1714 struct displaylist_handle * graphics_displaylist_open(struct displaylist *displaylist)
1715 {
1716         struct displaylist_handle *ret;
1717
1718         ret=g_new0(struct displaylist_handle, 1);
1719         ret->hl_head=ret->hl=g_hash_to_list(displaylist->dl);
1720
1721         return ret;
1722 }
1723
1724 /**
1725  * FIXME
1726  * @param <>
1727  * @returns <>
1728  * @author Martin Schaller (04/2008)
1729 */
1730 struct displayitem * graphics_displaylist_next(struct displaylist_handle *dlh)
1731 {
1732         struct displayitem *ret;
1733         if (! dlh->l) {
1734                 if (!dlh->hl)
1735                         return NULL;
1736                 dlh->l=dlh->hl->data;
1737                 dlh->hl=g_list_next(dlh->hl);
1738         }
1739         ret=dlh->l->data;
1740         dlh->l=g_list_next(dlh->l);
1741         return ret;
1742 }
1743
1744 /**
1745  * FIXME
1746  * @param <>
1747  * @returns <>
1748  * @author Martin Schaller (04/2008)
1749 */
1750 void graphics_displaylist_close(struct displaylist_handle *dlh)
1751 {
1752         g_list_free(dlh->hl_head);
1753         g_free(dlh);
1754 }
1755
1756 /**
1757  * FIXME
1758  * @param <>
1759  * @returns <>
1760  * @author Martin Schaller (04/2008)
1761 */
1762 struct displaylist * graphics_displaylist_new(void)
1763 {
1764         struct displaylist *ret=g_new(struct displaylist, 1);
1765
1766         ret->dl=g_hash_table_new(NULL,NULL);
1767
1768         return ret;
1769 }
1770
1771 /**
1772  * FIXME
1773  * @param <>
1774  * @returns <>
1775  * @author Martin Schaller (04/2008)
1776 */
1777 struct item * graphics_displayitem_get_item(struct displayitem *di)
1778 {
1779         return &di->item;
1780 }
1781
1782 /**
1783  * FIXME
1784  * @param <>
1785  * @returns <>
1786  * @author Martin Schaller (04/2008)
1787 */
1788 char * graphics_displayitem_get_label(struct displayitem *di)
1789 {
1790         return di->label;
1791 }
1792
1793 /**
1794  * FIXME
1795  * @param <>
1796  * @returns <>
1797  * @author Martin Schaller (04/2008)
1798 */
1799 static int within_dist_point(struct point *p0, struct point *p1, int dist)
1800 {
1801         if (p0->x == 32767 || p0->y == 32767 || p1->x == 32767 || p1->y == 32767)
1802                 return 0;
1803         if (p0->x == -32768 || p0->y == -32768 || p1->x == -32768 || p1->y == -32768)
1804                 return 0;
1805         if ((p0->x-p1->x)*(p0->x-p1->x) + (p0->y-p1->y)*(p0->y-p1->y) <= dist*dist) {
1806                 return 1;
1807         }
1808         return 0;
1809 }
1810
1811 /**
1812  * FIXME
1813  * @param <>
1814  * @returns <>
1815  * @author Martin Schaller (04/2008)
1816 */
1817 static int within_dist_line(struct point *p, struct point *line_p0, struct point *line_p1, int dist)
1818 {
1819         int vx,vy,wx,wy;
1820         int c1,c2;
1821         struct point line_p;
1822
1823         vx=line_p1->x-line_p0->x;
1824         vy=line_p1->y-line_p0->y;
1825         wx=p->x-line_p0->x;
1826         wy=p->y-line_p0->y;
1827
1828         c1=vx*wx+vy*wy;
1829         if ( c1 <= 0 )
1830                 return within_dist_point(p, line_p0, dist);
1831         c2=vx*vx+vy*vy;
1832         if ( c2 <= c1 )
1833                 return within_dist_point(p, line_p1, dist);
1834
1835         line_p.x=line_p0->x+vx*c1/c2;
1836         line_p.y=line_p0->y+vy*c1/c2;
1837         return within_dist_point(p, &line_p, dist);
1838 }
1839
1840 /**
1841  * FIXME
1842  * @param <>
1843  * @returns <>
1844  * @author Martin Schaller (04/2008)
1845 */
1846 static int within_dist_polyline(struct point *p, struct point *line_pnt, int count, int dist, int close)
1847 {
1848         int i;
1849         for (i = 0 ; i < count-1 ; i++) {
1850                 if (within_dist_line(p,line_pnt+i,line_pnt+i+1,dist)) {
1851                         return 1;
1852                 }
1853         }
1854         if (close)
1855                 return (within_dist_line(p,line_pnt,line_pnt+count-1,dist));
1856         return 0;
1857 }
1858
1859 /**
1860  * FIXME
1861  * @param <>
1862  * @returns <>
1863  * @author Martin Schaller (04/2008)
1864 */
1865 static int within_dist_polygon(struct point *p, struct point *poly_pnt, int count, int dist)
1866 {
1867         int i, j, c = 0;
1868         for (i = 0, j = count-1; i < count; j = i++) {
1869                 if ((((poly_pnt[i].y <= p->y) && ( p->y < poly_pnt[j].y )) ||
1870                 ((poly_pnt[j].y <= p->y) && ( p->y < poly_pnt[i].y))) &&
1871                 (p->x < (poly_pnt[j].x - poly_pnt[i].x) * (p->y - poly_pnt[i].y) / (poly_pnt[j].y - poly_pnt[i].y) + poly_pnt[i].x))
1872                         c = !c;
1873         }
1874         if (! c)
1875                 return within_dist_polyline(p, poly_pnt, count, dist, 1);
1876         return c;
1877 }
1878
1879 /**
1880  * FIXME
1881  * @param <>
1882  * @returns <>
1883  * @author Martin Schaller (04/2008)
1884 */
1885 int graphics_displayitem_within_dist(struct displayitem *di, struct point *p, int dist)
1886 {
1887         struct point pa[16384];
1888         int count;
1889
1890         count=transform(tg, pg, di->c, pa, di->count, 1, 0, NULL);
1891
1892         if (di->item.type < type_line) {
1893                 return within_dist_point(p, &pa[0], dist);
1894         }
1895         if (di->item.type < type_area) {
1896                 return within_dist_polyline(p, pa, count, dist, 0);
1897         }
1898         return within_dist_polygon(p, pa, count, dist);
1899 }