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 "map.h"
  40 #include "coord.h"
  41 #include "transform.h"
  42 #include "plugin.h"
  43 #include "profile.h"
  44 #include "mapset.h"
  45 #include "layout.h"
  46 #include "route.h"
  47 #include "util.h"
  48 #include "callback.h"
  49 #include "file.h"
  50
  51 static char *navit_sharedir;
  52
  53 //##############################################################################################################
  54 //# Description:
  55 //# Comment:
  56 //# Authors: Martin Schaller (04/2008)
  57 //##############################################################################################################
  58 struct graphics
  59 {
  60         struct graphics_priv *priv;
  61         struct graphics_methods meth;
  62         char *default_font;
  63         struct graphics_font *font[16];
  64         struct graphics_gc *gc[3];
  65         struct attr **attrs;
  66         struct callback_list *cbl;
  67         int ready;
  68 };
  69
  70
  71 struct displaylist {
  72         GHashTable *dl;
  73 };
  74
  75 /**
  76  * Creates a new graphics object
  77  * attr type required
  78  * @param <>
  79  * @returns <>
  80  * @author Martin Schaller (04/2008)
  81 */
  82 struct graphics * graphics_new(struct attr *parent, struct attr **attrs)
  83 {
  84         struct graphics *this_;
  85         struct attr *type_attr;
  86         struct graphics_priv * (*graphicstype_new)(struct navit *nav, struct graphics_methods *meth, struct attr **attrs, struct callback_list *cbl);
  87
  88         if (! (type_attr=attr_search(attrs, NULL, attr_type))) {
  89                 return NULL;
  90         }
  91
  92         graphicstype_new=plugin_get_graphics_type(type_attr->u.str);
  93         if (! graphicstype_new)
  94                 return NULL;
  95         this_=g_new0(struct graphics, 1);
  96         this_->cbl=callback_list_new();
  97         this_->priv=(*graphicstype_new)(parent->u.navit, &this_->meth, attrs, this_->cbl);
  98         this_->attrs=attr_list_dup(attrs);
  99         return this_;
 100 }
 101
 102 /**
 103  * FIXME
 104  * @param <>
 105  * @returns <>
 106  * @author Martin Schaller (04/2008)
 107 */
 108 int graphics_get_attr(struct graphics *this_, enum attr_type type, struct attr *attr, struct attr_iter *iter)
 109 {
 110         return attr_generic_get_attr(this_->attrs, NULL, type, attr, iter);
 111 }
 112
 113 /**
 114  * FIXME
 115  * @param <>
 116  * @returns <>
 117  * @author Martin Schaller (04/2008)
 118 */
 119 struct graphics * graphics_overlay_new(struct graphics *parent, struct point *p, int w, int h, int alpha, int wraparound)
 120 {
 121         struct graphics *this_;
 122         if (!parent->meth.overlay_new)
 123                 return NULL;
 124         this_=g_new0(struct graphics, 1);
 125         this_->priv=parent->meth.overlay_new(parent->priv, &this_->meth, p, w, h, alpha, wraparound);
 126         if (!this_->priv) {
 127                 g_free(this_);
 128                 this_=NULL;
 129         }
 130         return this_;
 131 }
 132
 133 /**
 134  * FIXME
 135  * @param <>
 136  * @returns <>
 137  * @author Martin Schaller (04/2008)
 138 */
 139 void graphics_init(struct graphics *this_)
 140 {
 141         this_->gc[0]=graphics_gc_new(this_);
 142         graphics_gc_set_background(this_->gc[0], &(struct color) { 0xffff, 0xefef, 0xb7b7, 0xffff});
 143         graphics_gc_set_foreground(this_->gc[0], &(struct color) { 0xffff, 0xefef, 0xb7b7, 0xffff });
 144         this_->gc[1]=graphics_gc_new(this_);
 145         graphics_gc_set_background(this_->gc[1], &(struct color) { 0x0000, 0x0000, 0x0000, 0xffff });
 146         graphics_gc_set_foreground(this_->gc[1], &(struct color) { 0xffff, 0xffff, 0xffff, 0xffff });
 147         this_->gc[2]=graphics_gc_new(this_);
 148         graphics_gc_set_background(this_->gc[2], &(struct color) { 0xffff, 0xffff, 0xffff, 0xffff });
 149         graphics_gc_set_foreground(this_->gc[2], &(struct color) { 0x0000, 0x0000, 0x0000, 0xffff });
 150         graphics_background_gc(this_, this_->gc[0]);
 151         navit_sharedir = getenv("NAVIT_SHAREDIR");
 152 }
 153
 154 /**
 155  * FIXME
 156  * @param <>
 157  * @returns <>
 158  * @author Martin Schaller (04/2008)
 159 */
 160 void * graphics_get_data(struct graphics *this_, char *type)
 161 {
 162         return (this_->meth.get_data(this_->priv, type));
 163 }
 164
 165 void graphics_add_callback(struct graphics *this_, struct callback *cb)
 166 {
 167         callback_list_add(this_->cbl, cb);
 168 }
 169
 170 /**
 171  * FIXME
 172  * @param <>
 173  * @returns <>
 174  * @author Martin Schaller (04/2008)
 175 */
 176 struct graphics_font * graphics_font_new(struct graphics *gra, int size, int flags)
 177 {
 178         struct graphics_font *this_;
 179
 180         this_=g_new0(struct graphics_font,1);
 181         this_->priv=gra->meth.font_new(gra->priv, &this_->meth, gra->default_font, size, flags);
 182         return this_;
 183 }
 184
 185 /**
 186  * Free all loaded fonts.
 187  * Used when switching layouts.
 188  * @param gra The graphics instance
 189  * @returns nothing
 190  * @author Sarah Nordstrom (05/2008)
 191  */
 192 void graphics_font_destroy_all(struct graphics *gra)
 193 {
 194         int i;
 195         for(i = 0 ; i < sizeof(gra->font) / sizeof(gra->font[0]); i++) {
 196                 if(!gra->font[i]) continue;
 197                 gra->font[i]->meth.font_destroy(gra->font[i]->priv);
 198                 gra->font[i] = NULL;
 199         }
 200 }
 201
 202 /**
 203  * FIXME
 204  * @param <>
 205  * @returns <>
 206  * @author Martin Schaller (04/2008)
 207 */
 208 struct graphics_gc * graphics_gc_new(struct graphics *gra)
 209 {
 210         struct graphics_gc *this_;
 211
 212         this_=g_new0(struct graphics_gc,1);
 213         this_->priv=gra->meth.gc_new(gra->priv, &this_->meth);
 214         return this_;
 215 }
 216
 217 /**
 218  * FIXME
 219  * @param <>
 220  * @returns <>
 221  * @author Martin Schaller (04/2008)
 222 */
 223 void graphics_gc_destroy(struct graphics_gc *gc)
 224 {
 225         gc->meth.gc_destroy(gc->priv);
 226         g_free(gc);
 227 }
 228
 229 /**
 230  * FIXME
 231  * @param <>
 232  * @returns <>
 233  * @author Martin Schaller (04/2008)
 234 */
 235 void graphics_gc_set_foreground(struct graphics_gc *gc, struct color *c)
 236 {
 237         gc->meth.gc_set_foreground(gc->priv, c);
 238 }
 239
 240 /**
 241  * FIXME
 242  * @param <>
 243  * @returns <>
 244  * @author Martin Schaller (04/2008)
 245 */
 246 void graphics_gc_set_background(struct graphics_gc *gc, struct color *c)
 247 {
 248         gc->meth.gc_set_background(gc->priv, c);
 249 }
 250
 251 /**
 252  * FIXME
 253  * @param <>
 254  * @returns <>
 255  * @author Martin Schaller (04/2008)
 256 */
 257 void graphics_gc_set_linewidth(struct graphics_gc *gc, int width)
 258 {
 259         gc->meth.gc_set_linewidth(gc->priv, width);
 260 }
 261
 262 /**
 263  * FIXME
 264  * @param <>
 265  * @returns <>
 266  * @author Martin Schaller (04/2008)
 267 */
 268 void graphics_gc_set_dashes(struct graphics_gc *gc, int width, int offset, unsigned char dash_list[], int n)
 269 {
 270         if (gc->meth.gc_set_dashes)
 271                 gc->meth.gc_set_dashes(gc->priv, width, offset, dash_list, n);
 272 }
 273
 274 /**
 275  * Create a new image from file path scaled to w and h pixels
 276  * @param gra the graphics instance
 277  * @param path path of the image to load
 278  * @param w width to rescale to
 279  * @param h height to rescale to
 280  * @returns <>
 281  * @author Martin Schaller (04/2008)
 282 */
 283 struct graphics_image * graphics_image_new_scaled(struct graphics *gra, char *path, int w, int h)
 284 {
 285         struct graphics_image *this_;
 286
 287         this_=g_new0(struct graphics_image,1);
 288         this_->height=h;
 289         this_->width=w;
 290         this_->priv=gra->meth.image_new(gra->priv, &this_->meth, path, &this_->width, &this_->height, &this_->hot, 0);
 291         if (! this_->priv) {
 292                 g_free(this_);
 293                 this_=NULL;
 294         }
 295         return this_;
 296 }
 297
 298 /**
 299  * Create a new image from file path scaled to w and h pixels and possibly rotated
 300  * @param gra the graphics instance
 301  * @param path path of the image to load
 302  * @param w width to rescale to
 303  * @param h height to rescale to
 304  * @param rotate angle to rotate the image. Warning, graphics might only support 90 degree steps here
 305  * @returns <>
 306  * @author Martin Schaller (04/2008)
 307 */
 308 struct graphics_image * graphics_image_new_scaled_rotated(struct graphics *gra, char *path, int w, int h, int rotate)
 309 {
 310         struct graphics_image *this_;
 311
 312         this_=g_new0(struct graphics_image,1);
 313         this_->height=h;
 314         this_->width=w;
 315         this_->priv=gra->meth.image_new(gra->priv, &this_->meth, path, &this_->width, &this_->height, &this_->hot, rotate);
 316         if (! this_->priv) {
 317                 g_free(this_);
 318                 this_=NULL;
 319         }
 320         return this_;
 321 }
 322
 323 /**
 324  * Create a new image from file path
 325  * @param gra the graphics instance
 326  * @param path path of the image to load
 327  * @returns <>
 328  * @author Martin Schaller (04/2008)
 329 */
 330 struct graphics_image * graphics_image_new(struct graphics *gra, char *path)
 331 {
 332         return graphics_image_new_scaled(gra, path, -1, -1);
 333 }
 334
 335 /**
 336  * FIXME
 337  * @param <>
 338  * @returns <>
 339  * @author Martin Schaller (04/2008)
 340 */
 341 void graphics_image_free(struct graphics *gra, struct graphics_image *img)
 342 {
 343         if (gra->meth.image_free)
 344                 gra->meth.image_free(gra->priv, img->priv);
 345         g_free(img);
 346 }
 347
 348 /**
 349  * FIXME
 350  * @param <>
 351  * @returns <>
 352  * @author Martin Schaller (04/2008)
 353 */
 354 void graphics_draw_restore(struct graphics *this_, struct point *p, int w, int h)
 355 {
 356         this_->meth.draw_restore(this_->priv, p, w, h);
 357 }
 358
 359 /**
 360  * FIXME
 361  * @param <>
 362  * @returns <>
 363  * @author Martin Schaller (04/2008)
 364 */
 365 void graphics_draw_mode(struct graphics *this_, enum draw_mode_num mode)
 366 {
 367         this_->meth.draw_mode(this_->priv, mode);
 368 }
 369
 370 /**
 371  * FIXME
 372  * @param <>
 373  * @returns <>
 374  * @author Martin Schaller (04/2008)
 375 */
 376 void graphics_draw_lines(struct graphics *this_, struct graphics_gc *gc, struct point *p, int count)
 377 {
 378         this_->meth.draw_lines(this_->priv, gc->priv, p, count);
 379 }
 380
 381 /**
 382  * FIXME
 383  * @param <>
 384  * @returns <>
 385  * @author Martin Schaller (04/2008)
 386 */
 387 void graphics_draw_circle(struct graphics *this_, struct graphics_gc *gc, struct point *p, int r)
 388 {
 389         this_->meth.draw_circle(this_->priv, gc->priv, p, r);
 390 }
 391
 392 /**
 393  * FIXME
 394  * @param <>
 395  * @returns <>
 396  * @author Martin Schaller (04/2008)
 397 */
 398 void graphics_draw_rectangle(struct graphics *this_, struct graphics_gc *gc, struct point *p, int w, int h)
 399 {
 400         this_->meth.draw_rectangle(this_->priv, gc->priv, p, w, h);
 401 }
 402
 403 /**
 404  * FIXME
 405  * @param <>
 406  * @returns <>
 407  * @author Martin Schaller (04/2008)
 408 */
 409 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)
 410 {
 411         this_->meth.draw_text(this_->priv, gc1->priv, gc2 ? gc2->priv : NULL, font->priv, text, p, dx, dy);
 412 }
 413
 414 /**
 415  * FIXME
 416  * @param <>
 417  * @returns <>
 418  * @author Martin Schaller (04/2008)
 419 */
 420 void graphics_get_text_bbox(struct graphics *this_, struct graphics_font *font, char *text, int dx, int dy, struct point *ret)
 421 {
 422         this_->meth.get_text_bbox(this_->priv, font->priv, text, dx, dy, ret);
 423 }
 424
 425 /**
 426  * FIXME
 427  * @param <>
 428  * @returns <>
 429  * @author Martin Schaller (04/2008)
 430 */
 431 void graphics_overlay_disable(struct graphics *this_, int disable)
 432 {
 433         if (this_->meth.overlay_disable)
 434                 this_->meth.overlay_disable(this_->priv, disable);
 435 }
 436
 437 /**
 438  * FIXME
 439  * @param <>
 440  * @returns <>
 441  * @author Martin Schaller (04/2008)
 442 */
 443 void graphics_draw_image(struct graphics *this_, struct graphics_gc *gc, struct point *p, struct graphics_image *img)
 444 {
 445         this_->meth.draw_image(this_->priv, gc->priv, p, img->priv);
 446 }
 447
 448
 449 //##############################################################################################################
 450 //# Description:
 451 //# Comment:
 452 //# Authors: Martin Schaller (04/2008)
 453 //##############################################################################################################
 454 int
 455 graphics_draw_drag(struct graphics *this_, struct point *p)
 456 {
 457         if (!this_->meth.draw_drag)
 458                 return 0;
 459         this_->meth.draw_drag(this_->priv, p);
 460         return 1;
 461 }
 462
 463 void
 464 graphics_background_gc(struct graphics *this_, struct graphics_gc *gc)
 465 {
 466         this_->meth.background_gc(this_->priv, gc ? gc->priv : NULL);
 467 }
 468
 469 #include "attr.h"
 470 #include "popup.h"
 471 #include <stdio.h>
 472
 473
 474 #if 0
 475 //##############################################################################################################
 476 //# Description:
 477 //# Comment:
 478 //# Authors: Martin Schaller (04/2008)
 479 //##############################################################################################################
 480 static void popup_view_html(struct popup_item *item, char *file)
 481 {
 482         char command[1024];
 483         sprintf(command,"firefox %s", file);
 484         system(command);
 485 }
 486
 487 //##############################################################################################################
 488 //# Description:
 489 //# Comment:
 490 //# Authors: Martin Schaller (04/2008)
 491 //##############################################################################################################
 492 static void graphics_popup(struct display_list *list, struct popup_item **popup)
 493 {
 494         struct item *item;
 495         struct attr attr;
 496         struct map_rect *mr;
 497         struct coord c;
 498         struct popup_item *curr_item,*last=NULL;
 499         item=list->data;
 500         mr=map_rect_new(item->map, NULL, NULL, 0);
 501         printf("id hi=0x%x lo=0x%x\n", item->id_hi, item->id_lo);
 502         item=map_rect_get_item_byid(mr, item->id_hi, item->id_lo);
 503         if (item) {
 504                 if (item_attr_get(item, attr_name, &attr)) {
 505                         curr_item=popup_item_new_text(popup,attr.u.str,1);
 506                         if (item_attr_get(item, attr_info_html, &attr)) {
 507                                 popup_item_new_func(&last,"HTML Info",1, popup_view_html, g_strdup(attr.u.str));
 508                         }
 509                         if (item_attr_get(item, attr_price_html, &attr)) {
 510                                 popup_item_new_func(&last,"HTML Preis",2, popup_view_html, g_strdup(attr.u.str));
 511                         }
 512                         curr_item->submenu=last;
 513                 }
 514         }
 515         map_rect_destroy(mr);
 516 }
 517 #endif
 518
 519 /**
 520  * FIXME
 521  * @param <>
 522  * @returns <>
 523  * @author Martin Schaller (04/2008)
 524 */
 525 struct displayitem {
 526         struct item item;
 527         char *label;
 528         int displayed;
 529         int count;
 530         struct point pnt[0];
 531 };
 532
 533 /**
 534  * FIXME
 535  * @param <>
 536  * @returns <>
 537  * @author Martin Schaller (04/2008)
 538 */
 539 static int xdisplay_free_list(gpointer key, gpointer value, gpointer user_data)
 540 {
 541         GList *h, *l;
 542         h=value;
 543         l=h;
 544         while (l) {
 545                 struct displayitem *di=l->data;
 546                 if (! di->displayed && di->item.type < type_line)
 547                         dbg(1,"warning: item '%s' not displayed\n", item_to_name(di->item.type));
 548                 g_free(l->data);
 549                 l=g_list_next(l);
 550         }
 551         g_list_free(h);
 552         return TRUE;
 553 }
 554
 555 /**
 556  * FIXME
 557  * @param <>
 558  * @returns <>
 559  * @author Martin Schaller (04/2008)
 560 */
 561 static void xdisplay_free(GHashTable *display_list)
 562 {
 563         g_hash_table_foreach_remove(display_list, xdisplay_free_list, NULL);
 564 }
 565
 566 /**
 567  * FIXME
 568  * @param <>
 569  * @returns <>
 570  * @author Martin Schaller (04/2008)
 571 */
 572 void display_add(struct displaylist *displaylist, struct item *item, int count, struct point *pnt, char *label)
 573 {
 574         struct displayitem *di;
 575         int len;
 576         GList *l;
 577         char *p;
 578
 579         len=sizeof(*di)+count*sizeof(*pnt);
 580         if (label)
 581                 len+=strlen(label)+1;
 582
 583         p=g_malloc(len);
 584
 585         di=(struct displayitem *)p;
 586         di->displayed=0;
 587         p+=sizeof(*di)+count*sizeof(*pnt);
 588         di->item=*item;
 589         if (label) {
 590                 di->label=p;
 591                 strcpy(di->label, label);
 592         } else
 593                 di->label=NULL;
 594         di->count=count;
 595         memcpy(di->pnt, pnt, count*sizeof(*pnt));
 596
 597         l=g_hash_table_lookup(displaylist->dl, GINT_TO_POINTER(item->type));
 598         l=g_list_prepend(l, di);
 599         g_hash_table_insert(displaylist->dl, GINT_TO_POINTER(item->type), l);
 600 }
 601
 602
 603 /**
 604  * FIXME
 605  * @param <>
 606  * @returns <>
 607  * @author Martin Schaller (04/2008)
 608 */
 609 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)
 610 {
 611         int i,x,y,tl;
 612         double dx,dy,l;
 613         struct point p_t;
 614
 615         tl=strlen(label)*400;
 616         for (i = 0 ; i < count-1 ; i++) {
 617                 dx=p[i+1].x-p[i].x;
 618                 dx*=100;
 619                 dy=p[i+1].y-p[i].y;
 620                 dy*=100;
 621                 l=(int)sqrt((float)(dx*dx+dy*dy));
 622                 if (l > tl) {
 623                         x=p[i].x;
 624                         y=p[i].y;
 625                         if (dx < 0) {
 626                                 dx=-dx;
 627                                 dy=-dy;
 628                                 x=p[i+1].x;
 629                                 y=p[i+1].y;
 630                         }
 631                         x+=(l-tl)*dx/l/200;
 632                         y+=(l-tl)*dy/l/200;
 633                         x-=dy*45/l/10;
 634                         y+=dx*45/l/10;
 635                         p_t.x=x;
 636                         p_t.y=y;
 637         #if 0
 638                         printf("display_text: '%s', %d, %d, %d, %d %d\n", label, x, y, dx*0x10000/l, dy*0x10000/l, l);
 639         #endif
 640                         gra->meth.draw_text(gra->priv, fg->priv, bg->priv, font->priv, label, &p_t, dx*0x10000/l, dy*0x10000/l);
 641                 }
 642         }
 643 }
 644
 645 static void display_draw_arrow(struct point *p, int dx, int dy, int l, struct graphics_gc *gc, struct graphics *gra)
 646 {
 647         struct point pnt[3];
 648         pnt[0]=pnt[1]=pnt[2]=*p;
 649         pnt[0].x+=-dx*l/65536+dy*l/65536;
 650         pnt[0].y+=-dy*l/65536-dx*l/65536;
 651         pnt[2].x+=-dx*l/65536-dy*l/65536;
 652         pnt[2].y+=-dy*l/65536+dx*l/65536;
 653         gra->meth.draw_lines(gra->priv, gc->priv, pnt, 3);
 654 }
 655
 656 static void display_draw_arrows(struct displayitem *di, struct graphics_gc *gc, struct graphics *gra)
 657 {
 658         int i,dx,dy,l;
 659         struct point p;
 660         for (i = 0 ; i < di->count-1 ; i++) {
 661                 dx=di->pnt[i+1].x-di->pnt[i].x;
 662                 dy=di->pnt[i+1].y-di->pnt[i].y;
 663                 l=sqrt(dx*dx+dy*dy);
 664                 if (l) {
 665                         dx=dx*65536/l;
 666                         dy=dy*65536/l;
 667                         p=di->pnt[i];
 668                         p.x+=dx*15/65536;
 669                         p.y+=dy*15/65536;
 670                         display_draw_arrow(&p, dx, dy, 10, gc, gra);
 671                         p=di->pnt[i+1];
 672                         p.x-=dx*15/65536;
 673                         p.y-=dy*15/65536;
 674                         display_draw_arrow(&p, dx, dy, 10, gc, gra);
 675                 }
 676         }
 677 }
 678
 679 /**
 680  * FIXME
 681  * @param <>
 682  * @returns <>
 683  * @author Martin Schaller (04/2008)
 684 */
 685 static void xdisplay_draw_elements(struct graphics *gra, GHashTable *display_list, struct itemgra *itm)
 686 {
 687         struct element *e;
 688         GList *l,*ls,*es,*types;
 689         enum item_type type;
 690         struct graphics_gc *gc = NULL;
 691         struct graphics_image *img;
 692         struct point p;
 693         char path[PATH_MAX];
 694
 695         es=itm->elements;
 696         while (es) {
 697                 e=es->data;
 698                 types=itm->type;
 699                 while (types) {
 700                         type=GPOINTER_TO_INT(types->data);
 701                         ls=g_hash_table_lookup(display_list, GINT_TO_POINTER(type));
 702                         l=ls;
 703                         if (gc)
 704                                 graphics_gc_destroy(gc);
 705                         gc=NULL;
 706                         img=NULL;
 707                         while (l) {
 708                                 struct displayitem *di;
 709                                 di=l->data;
 710                                 di->displayed=1;
 711                                 if (! gc) {
 712                                         gc=graphics_gc_new(gra);
 713                                         gc->meth.gc_set_foreground(gc->priv, &e->color);
 714                                 }
 715                                 switch (e->type) {
 716                                 case element_polygon:
 717                                         gra->meth.draw_polygon(gra->priv, gc->priv, di->pnt, di->count);
 718                                         break;
 719                                 case element_polyline:
 720                                         if (e->u.polyline.width > 1)
 721                                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
 722                                         if (e->u.polyline.width > 0 && e->u.polyline.dash_num > 0)
 723                                                 graphics_gc_set_dashes(gc, e->u.polyline.width,
 724                                                                        e->u.polyline.offset,
 725                                                                        e->u.polyline.dash_table,
 726                                                                        e->u.polyline.dash_num);
 727                                         gra->meth.draw_lines(gra->priv, gc->priv, di->pnt, di->count);
 728                                         break;
 729                                 case element_circle:
 730                                         if (e->u.circle.width > 1)
 731                                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
 732                                         gra->meth.draw_circle(gra->priv, gc->priv, &di->pnt[0], e->u.circle.radius);
 733                                         if (di->label && e->text_size) {
 734                                                 p.x=di->pnt[0].x+3;
 735                                                 p.y=di->pnt[0].y+10;
 736                                                 if (! gra->font[e->text_size])
 737                                                         gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
 738                                                 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);
 739                                         }
 740                                         break;
 741                                 case element_text:
 742                                         if (di->label) {
 743                                                 if (! gra->font[e->text_size])
 744                                                         gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
 745                                                 label_line(gra, gra->gc[2], gra->gc[1], gra->font[e->text_size], di->pnt, di->count, di->label);
 746                                         }
 747                                         break;
 748                                 case element_icon:
 749                                         if (!img) {
 750                                                 sprintf(path,"%s/xpm/%s", navit_sharedir, e->u.icon.src);
 751                                                 img=graphics_image_new_scaled_rotated(gra, path, e->u.icon.width, e->u.icon.height, e->u.icon.rotation);
 752                                                 if (! img)
 753                                                         dbg(0,"failed to load icon '%s'\n", e->u.icon.src);
 754                                         }
 755                                         if (img) {
 756                                                 p.x=di->pnt[0].x - img->hot.x;
 757                                                 p.y=di->pnt[0].y - img->hot.y;
 758                                                 gra->meth.draw_image(gra->priv, gra->gc[0]->priv, &p, img->priv);
 759                                                 graphics_image_free(gra, img);
 760                                                 img = NULL;
 761                                         }
 762                                         break;
 763                                 case element_image:
 764                                         dbg(1,"image: '%s'\n", di->label);
 765                                         if (gra->meth.draw_image_warp)
 766                                                 gra->meth.draw_image_warp(gra->priv, gra->gc[0]->priv, di->pnt, di->count, di->label);
 767                                         else
 768                                                 dbg(0,"draw_image_warp not supported by graphics driver drawing '%s'\n", di->label);
 769                                         break;
 770                                 case element_arrows:
 771                                         display_draw_arrows(di,gc,gra);
 772                                         break;
 773                                 default:
 774                                         printf("Unhandled element type %d\n", e->type);
 775
 776                                 }
 777                                 l=g_list_next(l);
 778                         }
 779                         types=g_list_next(types);
 780                 }
 781                 es=g_list_next(es);
 782         }
 783         if (gc)
 784                 graphics_gc_destroy(gc);
 785 }
 786
 787 void
 788 graphics_draw_itemgra(struct graphics *gra, struct itemgra *itm, struct transformation *t)
 789 {
 790         GList *es;
 791         struct point p;
 792         struct coord c;
 793         char *label=NULL;
 794         struct graphics_gc *gc = NULL;
 795         struct graphics_image *img;
 796         char path[PATH_MAX];
 797         es=itm->elements;
 798         c.x=0;
 799         c.y=0;
 800         while (es) {
 801                 struct element *e=es->data;
 802                 int count=e->coord_count;
 803                 struct point pnt[count+1];
 804                 if (count)
 805                         transform(t, projection_screen, e->coord, pnt, count, 0);
 806                 else {
 807                         transform(t, projection_screen, &c, pnt, 1, 0);
 808                         count=1;
 809                 }
 810                 gc=graphics_gc_new(gra);
 811                 gc->meth.gc_set_foreground(gc->priv, &e->color);
 812                 switch (e->type) {
 813                 case element_polyline:
 814                         if (e->u.polyline.width > 1)
 815                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
 816                         if (e->u.polyline.width > 0 && e->u.polyline.dash_num > 0)
 817                                 graphics_gc_set_dashes(gc, e->u.polyline.width,
 818                                                        e->u.polyline.offset,
 819                                                        e->u.polyline.dash_table,
 820                                                        e->u.polyline.dash_num);
 821                         gra->meth.draw_lines(gra->priv, gc->priv, pnt, count);
 822                         break;
 823                 case element_circle:
 824                         if (e->u.circle.width > 1)
 825                                 gc->meth.gc_set_linewidth(gc->priv, e->u.polyline.width);
 826                         gra->meth.draw_circle(gra->priv, gc->priv, &pnt[0], e->u.circle.radius);
 827                         if (label && e->text_size) {
 828                                 p.x=pnt[0].x+3;
 829                                 p.y=pnt[0].y+10;
 830                         if (! gra->font[e->text_size])
 831                                 gra->font[e->text_size]=graphics_font_new(gra, e->text_size*20, 0);
 832                                 gra->meth.draw_text(gra->priv, gra->gc[2]->priv, gra->gc[1]->priv, gra->font[e->text_size]->priv, label, &p, 0x10000, 0);
 833                         }
 834                         break;
 835                 case element_icon:
 836                         sprintf(path,"%s/xpm/%s", navit_sharedir, e->u.icon.src);
 837                         img=graphics_image_new_scaled_rotated(gra, path, e->u.icon.width, e->u.icon.height, e->u.icon.rotation);
 838                         if (! img)
 839                                 dbg(0,"failed to load icon '%s'\n", e->u.icon.src);
 840                         else {
 841                                 p.x=pnt[0].x - img->hot.x;
 842                                 p.y=pnt[0].y - img->hot.y;
 843                                 gra->meth.draw_image(gra->priv, gc->priv, &p, img->priv);
 844                                 graphics_image_free(gra, img);
 845                         }
 846                         break;
 847                 default:
 848                         dbg(0,"dont know how to draw %d\n", e->type);
 849                 }
 850                 graphics_gc_destroy(gc);
 851                 es=g_list_next(es);
 852         }
 853 }
 854
 855 /**
 856  * FIXME
 857  * @param <>
 858  * @returns <>
 859  * @author Martin Schaller (04/2008)
 860 */
 861 static void xdisplay_draw_layer(GHashTable *display_list, struct graphics *gra, struct layer *lay, int order)
 862 {
 863         GList *itms;
 864         struct itemgra *itm;
 865
 866         itms=lay->itemgras;
 867         while (itms) {
 868                 itm=itms->data;
 869                 if (order >= itm->order.min && order <= itm->order.max)
 870                         xdisplay_draw_elements(gra, display_list, itm);
 871                 itms=g_list_next(itms);
 872         }
 873 }
 874
 875 /**
 876  * FIXME
 877  * @param <>
 878  * @returns <>
 879  * @author Martin Schaller (04/2008)
 880 */
 881 static void xdisplay_draw(GHashTable *display_list, struct graphics *gra, struct layout *l, int order)
 882 {
 883         GList *lays;
 884         struct layer *lay;
 885
 886         lays=l->layers;
 887         while (lays) {
 888                 lay=lays->data;
 889                 xdisplay_draw_layer(display_list, gra, lay, order);
 890                 lays=g_list_next(lays);
 891         }
 892 }
 893
 894 /**
 895  * FIXME
 896  * @param <>
 897  * @returns <>
 898  * @author Martin Schaller (04/2008)
 899 */
 900 extern void *route_selection;
 901
 902 /**
 903  * FIXME
 904  * @param <>
 905  * @returns <>
 906  * @author Martin Schaller (04/2008)
 907 */
 908 static void do_draw_map(struct displaylist *displaylist, struct transformation *t, struct map *m, int order)
 909 {
 910         enum projection pro;
 911         struct map_rect *mr;
 912         struct item *item;
 913         int conv,count,max=16384;
 914         struct point pnt[max];
 915         struct coord ca[max];
 916         struct attr attr;
 917         struct map_selection *sel;
 918
 919         pro=map_projection(m);
 920         conv=map_requires_conversion(m);
 921         sel=transform_get_selection(t, pro, order);
 922         if (route_selection)
 923                 mr=map_rect_new(m, route_selection);
 924         else
 925                 mr=map_rect_new(m, sel);
 926         if (! mr) {
 927                 map_selection_destroy(sel);
 928                 return;
 929         }
 930         while ((item=map_rect_get_item(mr))) {
 931                 count=item_coord_get(item, ca, item->type < type_line ? 1: max);
 932                 if (item->type >= type_line && count < 2) {
 933                         dbg(1,"poly from map has only %d points\n", count);
 934                         continue;
 935                 }
 936                 if (item->type < type_line) {
 937                         if (! map_selection_contains_point(sel, &ca[0])) {
 938                                 dbg(1,"point not visible\n");
 939                                 continue;
 940                         }
 941                 } else if (item->type < type_area) {
 942                         if (! map_selection_contains_polyline(sel, ca, count)) {
 943                                 dbg(1,"polyline not visible\n");
 944                                 continue;
 945                         }
 946                 } else {
 947                         if (! map_selection_contains_polygon(sel, ca, count)) {
 948                                 dbg(1,"polygon not visible\n");
 949                                 continue;
 950                         }
 951                 }
 952                 if (count == max)
 953                         dbg(0,"point count overflow\n", count);
 954                 count=transform(t, pro, ca, pnt, count, 1);
 955                 if (item->type >= type_line && count < 2) {
 956                         dbg(1,"poly from transform has only %d points\n", count);
 957                         continue;
 958                 }
 959                 if (!item_attr_get(item, attr_label, &attr))
 960                         attr.u.str=NULL;
 961                 if (conv && attr.u.str && attr.u.str[0]) {
 962                         char *str=map_convert_string(m, attr.u.str);
 963                         display_add(displaylist, item, count, pnt, str);
 964                         map_convert_free(str);
 965                 } else
 966                         display_add(displaylist, item, count, pnt, attr.u.str);
 967         }
 968         map_rect_destroy(mr);
 969         map_selection_destroy(sel);
 970 }
 971
 972 /**
 973  * FIXME
 974  * @param <>
 975  * @returns <>
 976  * @author Martin Schaller (04/2008)
 977 */
 978 static void do_draw(struct displaylist *displaylist, struct transformation *t, GList *mapsets, int order)
 979 {
 980         struct mapset *ms;
 981         struct map *m;
 982         struct mapset_handle *h;
 983
 984         if (! mapsets)
 985                 return;
 986         ms=mapsets->data;
 987         h=mapset_open(ms);
 988         while ((m=mapset_next(h, 1))) {
 989                 do_draw_map(displaylist, t, m, order);
 990         }
 991         mapset_close(h);
 992 }
 993
 994 /**
 995  * FIXME
 996  * @param <>
 997  * @returns <>
 998  * @author Martin Schaller (04/2008)
 999 */
1000 int graphics_ready(struct graphics *this_)
1001 {
1002         return this_->ready;
1003 }
1004
1005 /**
1006  * FIXME
1007  * @param <>
1008  * @returns <>
1009  * @author Martin Schaller (04/2008)
1010 */
1011 void graphics_displaylist_draw(struct graphics *gra, struct displaylist *displaylist, struct transformation *trans, struct layout *l, int callback)
1012 {
1013         int order=transform_get_order(trans);
1014         struct point p;
1015         p.x=0;
1016         p.y=0;
1017         // FIXME find a better place to set the background color
1018         graphics_gc_set_background(gra->gc[0], &l->color);
1019         graphics_gc_set_foreground(gra->gc[0], &l->color);
1020         gra->default_font = g_strdup(l->font);
1021         graphics_background_gc(gra, gra->gc[0]);
1022         gra->meth.draw_mode(gra->priv, draw_mode_begin);
1023         gra->meth.draw_rectangle(gra->priv, gra->gc[0]->priv, &p, 32767, 32767);
1024         xdisplay_draw(displaylist->dl, gra, l, order+l->order_delta);
1025         if (callback)
1026                 callback_list_call_attr_0(gra->cbl, attr_postdraw);
1027         gra->meth.draw_mode(gra->priv, draw_mode_end);
1028 }
1029
1030 /**
1031  * FIXME
1032  * @param <>
1033  * @returns <>
1034  * @author Martin Schaller (04/2008)
1035 */
1036 void graphics_displaylist_move(struct displaylist *displaylist, int dx, int dy)
1037 {
1038         struct displaylist_handle *dlh;
1039         struct displayitem *di;
1040         int i;
1041
1042         dlh=graphics_displaylist_open(displaylist);
1043         while ((di=graphics_displaylist_next(dlh))) {
1044                 for (i = 0 ; i < di->count ; i++) {
1045                         di->pnt[i].x+=dx;
1046                         di->pnt[i].y+=dy;
1047                 }
1048         }
1049         graphics_displaylist_close(dlh);
1050 }
1051
1052 /**
1053  * FIXME
1054  * @param <>
1055  * @returns <>
1056  * @author Martin Schaller (04/2008)
1057 */
1058 void graphics_draw(struct graphics *gra, struct displaylist *displaylist, GList *mapsets, struct transformation *trans, struct layout *l)
1059 {
1060         int order=transform_get_order(trans);
1061
1062         dbg(1,"enter");
1063
1064 #if 0
1065         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));
1066 #endif
1067
1068         xdisplay_free(displaylist->dl);
1069         dbg(1,"order=%d\n", order);
1070
1071
1072 #if 0
1073         for (i = 0 ; i < data_window_type_end; i++) {
1074                 data_window_begin(co->data_window[i]);
1075         }
1076 #endif
1077         profile(0,NULL);
1078         order+=l->order_delta;
1079         do_draw(displaylist, trans, mapsets, order);
1080 //      profile(1,"do_draw");
1081         graphics_displaylist_draw(gra, displaylist, trans, l, 1);
1082         profile(1,"xdisplay_draw");
1083         profile(0,"end");
1084
1085 #if 0
1086         for (i = 0 ; i < data_window_type_end; i++) {
1087                 data_window_end(co->data_window[i]);
1088         }
1089 #endif
1090         gra->ready=1;
1091 }
1092
1093 /**
1094  * FIXME
1095  * @param <>
1096  * @returns <>
1097  * @author Martin Schaller (04/2008)
1098 */
1099 struct displaylist_handle {
1100         GList *hl_head,*hl,*l;
1101 };
1102
1103 /**
1104  * FIXME
1105  * @param <>
1106  * @returns <>
1107  * @author Martin Schaller (04/2008)
1108 */
1109 struct displaylist_handle * graphics_displaylist_open(struct displaylist *displaylist)
1110 {
1111         struct displaylist_handle *ret;
1112
1113         ret=g_new0(struct displaylist_handle, 1);
1114         ret->hl_head=ret->hl=g_hash_to_list(displaylist->dl);
1115
1116         return ret;
1117 }
1118
1119 /**
1120  * FIXME
1121  * @param <>
1122  * @returns <>
1123  * @author Martin Schaller (04/2008)
1124 */
1125 struct displayitem * graphics_displaylist_next(struct displaylist_handle *dlh)
1126 {
1127         struct displayitem *ret;
1128         if (! dlh->l) {
1129                 if (!dlh->hl)
1130                         return NULL;
1131                 dlh->l=dlh->hl->data;
1132                 dlh->hl=g_list_next(dlh->hl);
1133         }
1134         ret=dlh->l->data;
1135         dlh->l=g_list_next(dlh->l);
1136         return ret;
1137 }
1138
1139 /**
1140  * FIXME
1141  * @param <>
1142  * @returns <>
1143  * @author Martin Schaller (04/2008)
1144 */
1145 void graphics_displaylist_close(struct displaylist_handle *dlh)
1146 {
1147         g_list_free(dlh->hl_head);
1148         g_free(dlh);
1149 }
1150
1151 /**
1152  * FIXME
1153  * @param <>
1154  * @returns <>
1155  * @author Martin Schaller (04/2008)
1156 */
1157 struct displaylist * graphics_displaylist_new(void)
1158 {
1159         struct displaylist *ret=g_new(struct displaylist, 1);
1160
1161         ret->dl=g_hash_table_new(NULL,NULL);
1162
1163         return ret;
1164 }
1165
1166 /**
1167  * FIXME
1168  * @param <>
1169  * @returns <>
1170  * @author Martin Schaller (04/2008)
1171 */
1172 struct item * graphics_displayitem_get_item(struct displayitem *di)
1173 {
1174         return &di->item;
1175 }
1176
1177 /**
1178  * FIXME
1179  * @param <>
1180  * @returns <>
1181  * @author Martin Schaller (04/2008)
1182 */
1183 char * graphics_displayitem_get_label(struct displayitem *di)
1184 {
1185         return di->label;
1186 }
1187
1188 /**
1189  * FIXME
1190  * @param <>
1191  * @returns <>
1192  * @author Martin Schaller (04/2008)
1193 */
1194 static int within_dist_point(struct point *p0, struct point *p1, int dist)
1195 {
1196         if (p0->x == 32767 || p0->y == 32767 || p1->x == 32767 || p1->y == 32767)
1197                 return 0;
1198         if (p0->x == -32768 || p0->y == -32768 || p1->x == -32768 || p1->y == -32768)
1199                 return 0;
1200         if ((p0->x-p1->x)*(p0->x-p1->x) + (p0->y-p1->y)*(p0->y-p1->y) <= dist*dist) {
1201                 return 1;
1202         }
1203         return 0;
1204 }
1205
1206 /**
1207  * FIXME
1208  * @param <>
1209  * @returns <>
1210  * @author Martin Schaller (04/2008)
1211 */
1212 static int within_dist_line(struct point *p, struct point *line_p0, struct point *line_p1, int dist)
1213 {
1214         int vx,vy,wx,wy;
1215         int c1,c2;
1216         struct point line_p;
1217
1218         vx=line_p1->x-line_p0->x;
1219         vy=line_p1->y-line_p0->y;
1220         wx=p->x-line_p0->x;
1221         wy=p->y-line_p0->y;
1222
1223         c1=vx*wx+vy*wy;
1224         if ( c1 <= 0 )
1225                 return within_dist_point(p, line_p0, dist);
1226         c2=vx*vx+vy*vy;
1227         if ( c2 <= c1 )
1228                 return within_dist_point(p, line_p1, dist);
1229
1230         line_p.x=line_p0->x+vx*c1/c2;
1231         line_p.y=line_p0->y+vy*c1/c2;
1232         return within_dist_point(p, &line_p, dist);
1233 }
1234
1235 /**
1236  * FIXME
1237  * @param <>
1238  * @returns <>
1239  * @author Martin Schaller (04/2008)
1240 */
1241 static int within_dist_polyline(struct point *p, struct point *line_pnt, int count, int dist, int close)
1242 {
1243         int i;
1244         for (i = 0 ; i < count-1 ; i++) {
1245                 if (within_dist_line(p,line_pnt+i,line_pnt+i+1,dist)) {
1246                         return 1;
1247                 }
1248         }
1249         if (close)
1250                 return (within_dist_line(p,line_pnt,line_pnt+count-1,dist));
1251         return 0;
1252 }
1253
1254 /**
1255  * FIXME
1256  * @param <>
1257  * @returns <>
1258  * @author Martin Schaller (04/2008)
1259 */
1260 static int within_dist_polygon(struct point *p, struct point *poly_pnt, int count, int dist)
1261 {
1262         int i, j, c = 0;
1263         for (i = 0, j = count-1; i < count; j = i++) {
1264                 if ((((poly_pnt[i].y <= p->y) && ( p->y < poly_pnt[j].y )) ||
1265                 ((poly_pnt[j].y <= p->y) && ( p->y < poly_pnt[i].y))) &&
1266                 (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))
1267                         c = !c;
1268         }
1269         if (! c)
1270                 return within_dist_polyline(p, poly_pnt, count, dist, 1);
1271         return c;
1272 }
1273
1274 /**
1275  * FIXME
1276  * @param <>
1277  * @returns <>
1278  * @author Martin Schaller (04/2008)
1279 */
1280 int graphics_displayitem_within_dist(struct displayitem *di, struct point *p, int dist)
1281 {
1282         if (di->item.type < type_line) {
1283                 return within_dist_point(p, &di->pnt[0], dist);
1284         }
1285         if (di->item.type < type_area) {
1286                 return within_dist_polyline(p, di->pnt, di->count, dist, 0);
1287         }
1288         return within_dist_polygon(p, di->pnt, di->count, dist);
1289 }