err.no Git - mapper/blob - src/poi-gui.c

   1 #include <config.h>
   2
   3 #include <unistd.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <strings.h>
   7 #include <stddef.h>
   8 #include <locale.h>
   9 #include <math.h>
  10 #include <errno.h>
  11 #include <sys/wait.h>
  12 #include <glib/gstdio.h>
  13 #include <gtk/gtk.h>
  14 #include <fcntl.h>
  15 #include <libintl.h>
  16 #include <locale.h>
  17 #include <gtkhtml/gtkhtml.h>
  18 #include <gtkhtml/gtkhtml-stream.h>
  19
  20 #include "utils.h"
  21 #include "poi.h"
  22 #include "gps.h"
  23 #include "map.h"
  24 #include "mapper-types.h"
  25 #include "latlon.h"
  26 #include "ui-common.h"
  27 #include "settings.h"
  28 #include "poi-gui.h"
  29 #include "osm.h"
  30 #include "osm-db.h"
  31 #include "dialogs.h"
  32 #include "help.h"
  33 #include "track.h"
  34 #include "poi-gui.h"
  35
  36 #ifdef WITH_OSSO
  37 #include <libosso.h>
  38 #ifdef WITH_HILDON_NEW
  39 #include <tablet-browser-interface.h>
  40 #else
  41 #include <osso-browser-interface.h>
  42 #endif
  43 #include "ui-maemo.h"
  44 #endif
  45
  46 typedef struct _search_dialog search_dialog;
  47 struct _search_dialog {
  48         GtkWidget *dialog;
  49         GtkWidget *list;
  50         GtkWidget *cmb_category;
  51         GtkWidget *search_entry;
  52         GtkListStore *store;
  53         gdouble lat;
  54         gdouble lon;
  55 };
  56
  57 static search_dialog sd;
  58
  59 typedef struct _PoiCategoryEditInfo PoiCategoryEditInfo;
  60 struct _PoiCategoryEditInfo {
  61         GtkWidget *cmb_category;
  62         guint cat_id;
  63 };
  64
  65 /* XXX: Load this from somewhere instead of hc... */
  66 struct _quick_poi_categories {
  67     node_type_t type;
  68     const gchar *name;
  69 };
  70
  71 #define QPBS_X (4)
  72 #define QPBS_Y (3)
  73 #define POI_QUICK_BUTTONS (QPBS_X*QPBS_Y)
  74
  75 static struct _quick_poi_categories quick_poi_categories[] = {
  76         { NODE_AMENITY_SPEEDCAM,        "Speedcam", },
  77         { NODE_AMENITY_FUEL,            "Fuel", },
  78         { NODE_AMENITY_PARKING,         "Parking", },
  79         { NODE_AMENITY_TAXI,            "Taxi", },
  80
  81         { NODE_AMENITY_PUB,             "Pub", },
  82         { NODE_AMENITY_CAFE,            "Cafe", },
  83         { NODE_AMENITY_FOOD,            "Fast Food", },
  84         { NODE_AMENITY_RESTAURANT,      "Restaurant", },
  85
  86         { NODE_AMENITY_SHOP,            "Shop", },
  87         { NODE_AMENITY_BANK,            "Bank", },
  88         { NODE_AMENITY_ATM,             "ATM", },
  89         { NODE_AMENITY_POST_BOX,        "Post box", },
  90 };
  91
  92 static poi_quick_data qp;
  93
  94 static gboolean
  95 category_delete(GtkWidget *widget, delete_poi *dpoi)
  96 {
  97 GtkWidget *dialog;
  98 guint i;
  99 gchar *buffer;
 100
 101 buffer = g_strdup_printf("%s\n\t%s\n%s", _("Delete category?"),
 102                          dpoi->txt_label, _("WARNING: All POIs in that category will also be deleted!"));
 103 dialog = hildon_note_new_confirmation(GTK_WINDOW(_window), buffer);
 104 g_free(buffer);
 105 i = gtk_dialog_run(GTK_DIALOG(dialog));
 106 gtk_widget_destroy(GTK_WIDGET(dialog));
 107
 108 if (i == GTK_RESPONSE_OK) {
 109         if (poi_category_delete(dpoi->id)==FALSE)
 110                 popup_error(_window, _("Problem deleting category or POI"));
 111         gtk_widget_hide_all(dpoi->dialog);
 112         map_poi_cache_clear();
 113         map_force_redraw();
 114 }
 115
 116 return TRUE;
 117 }
 118
 119 GtkWidget *
 120 category_combo_new(void)
 121 {
 122 GtkWidget *cmb;
 123 GtkCellRenderer *renderer;
 124
 125 /* Category ID, Label */
 126 cmb=gtk_combo_box_new_with_model(GTK_TREE_MODEL(gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING)));
 127
 128 /* Set up the text view for the combo box. */
 129 renderer=gtk_cell_renderer_text_new();
 130 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cmb), renderer, TRUE);
 131 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cmb), renderer, "text", 1, NULL);
 132
 133 #if 0
 134 renderer=gtk_cell_renderer_pixbuf_new();
 135 column=gtk_tree_view_column_new_with_attributes(_("Icon"), renderer, "pixbuf", CAT_ICON, NULL);
 136 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 137 #endif
 138
 139 return cmb;
 140 }
 141
 142 void
 143 poi_category_combo_populate(GtkWidget *cmb_category, guint cat_id, gboolean add_na)
 144 {
 145 GtkTreeIter active;
 146 GtkListStore *store;
 147 GtkTreeIter iter;
 148 gboolean has_active = FALSE;
 149
 150 store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(cmb_category)));
 151 gtk_list_store_clear(store);
 152
 153 if (add_na) {
 154         gtk_list_store_append(store, &iter);
 155         gtk_list_store_set(store, &iter, 0, -1, 1, _("[No category]"), -1);
 156 }
 157
 158 while (SQLITE_ROW == sqlite3_step(poisql.selall_cat)) {
 159         guint cid = sqlite3_column_int(poisql.selall_cat, 0);
 160         gtk_list_store_append(store, &iter);
 161         gtk_list_store_set(store, &iter,
 162                 0, cid,
 163                 1, sqlite3_column_text(poisql.selall_cat, 1), -1);
 164         if (cid==cat_id) {
 165                 active=iter;
 166                 has_active=TRUE;
 167         }
 168 }
 169 sqlite3_reset(poisql.selall_cat);
 170
 171 if (!has_active)
 172         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &active);
 173
 174 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(cmb_category), &active);
 175 }
 176
 177 gboolean
 178 poi_category_dialog(guint cat_id)
 179 {
 180 GtkWidget *dialog;
 181 GtkWidget *table;
 182 GtkWidget *label;
 183 GtkWidget *txt_label;
 184 GtkWidget *txt_desc;
 185 GtkWidget *btn_delete = NULL;
 186 GtkWidget *txt_scroll;
 187 GtkWidget *chk_enabled;
 188 GtkTextBuffer *desc_txt;
 189 GtkTextIter begin, end;
 190 gboolean results = TRUE;
 191 delete_poi dpoi = { NULL, NULL, 0 };
 192 poi_category *c;
 193
 194 if (cat_id > 0) {
 195         if (poi_category_get(cat_id, &c)==FALSE) {
 196                 popup_error(_window, "Failed to get category.");
 197                 return FALSE;
 198         }
 199
 200         dialog = gtk_dialog_new_with_buttons(_("Edit Category"),
 201                                      GTK_WINDOW(_window),
 202                                      GTK_DIALOG_MODAL,
 203                                      GTK_STOCK_OK,
 204                                      GTK_RESPONSE_ACCEPT, NULL);
 205
 206         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
 207                           btn_delete = gtk_button_new_with_label(_("Delete")));
 208
 209         dpoi.dialog = dialog;
 210         dpoi.txt_label = g_strdup(c->label);
 211         dpoi.id = c->id;
 212
 213         g_signal_connect(G_OBJECT(btn_delete), "clicked", G_CALLBACK(category_delete), &dpoi);
 214         gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
 215 } else {
 216         c=poi_category_new();
 217         c->enabled = 1;
 218         c->label = g_strdup("");
 219         c->id = 0;
 220         c->desc = g_strdup("");
 221
 222         dialog = gtk_dialog_new_with_buttons(_("Add Category"),
 223                                      GTK_WINDOW(_window),
 224                                      GTK_DIALOG_MODAL,
 225                                      GTK_STOCK_OK,
 226                                      GTK_RESPONSE_ACCEPT,
 227                                      GTK_STOCK_CANCEL,
 228                                      GTK_RESPONSE_REJECT, NULL);
 229 }
 230
 231 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table = gtk_table_new(6, 4, FALSE), TRUE, TRUE, 0);
 232
 233 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Label")), 0, 1, 0, 1, GTK_FILL, 0, 2, 4);
 234 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 235 gtk_table_attach(GTK_TABLE(table), txt_label = gtk_entry_new(), 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 236 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Description")), 0, 1, 1, 2, GTK_FILL, 0, 2, 4);
 237 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 238 txt_scroll = gtk_scrolled_window_new(NULL, NULL);
 239 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scroll), GTK_SHADOW_IN);
 240 gtk_table_attach(GTK_TABLE(table), txt_scroll, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 241
 242 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 243
 244 txt_desc = gtk_text_view_new();
 245 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt_desc), GTK_WRAP_WORD);
 246
 247 gtk_container_add(GTK_CONTAINER(txt_scroll), txt_desc);
 248 gtk_widget_set_size_request(GTK_WIDGET(txt_scroll), 400, 60);
 249
 250 gtk_table_attach(GTK_TABLE(table), chk_enabled = gtk_check_button_new_with_label(_("Enabled")), 0, 2, 2, 3, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 251
 252 /* label */
 253 gtk_entry_set_text(GTK_ENTRY(txt_label), c->label);
 254
 255 /* desc */
 256 desc_txt = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_desc));
 257 gtk_text_buffer_set_text(desc_txt, c->desc, -1);
 258
 259 /* enabled */
 260 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_enabled), (c->enabled == 1 ? TRUE : FALSE));
 261
 262 poi_category_free(c);
 263
 264 gtk_widget_show_all(dialog);
 265
 266 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 267         if (strlen(gtk_entry_get_text(GTK_ENTRY(txt_label)))) {
 268                 c=poi_category_new();
 269                 c->label=g_strdup(gtk_entry_get_text(GTK_ENTRY(txt_label)));
 270         } else {
 271                 popup_error(dialog,_("Please specify a name for the category."));
 272                 continue;
 273         }
 274
 275         gtk_text_buffer_get_bounds(desc_txt, &begin, &end);
 276         c->desc = gtk_text_buffer_get_text(desc_txt, &begin, &end, TRUE);
 277         c->enabled = (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(chk_enabled)) ? 1 : 0);
 278
 279         results=poi_category_update(cat_id, c);
 280
 281         if (results==FALSE)
 282                 popup_error(_window, _("Problem updating category"));
 283         poi_category_free(c);
 284
 285         break;
 286 }
 287
 288 if (dpoi.txt_label)
 289         g_free(dpoi.txt_label);
 290 gtk_widget_destroy(dialog);
 291
 292 return results;
 293 }
 294
 295 static void
 296 category_toggled_cb(GtkCellRendererToggle *cell, gchar *path, gpointer data)
 297 {
 298 GtkTreeIter iter;
 299 gboolean cat_enabled;
 300 guint cat_id;
 301
 302 GtkTreeModel *model = GTK_TREE_MODEL(data);
 303 if (!gtk_tree_model_get_iter_from_string(model, &iter, path))
 304         return;
 305
 306 gtk_tree_model_get(model, &iter, CAT_ENABLED, &cat_enabled, -1);
 307 gtk_tree_model_get(model, &iter, CAT_ID, &cat_id, -1);
 308
 309 cat_enabled ^= 1;
 310
 311 if (poi_category_toggle(cat_id, cat_enabled)==FALSE) {
 312         popup_error(_window, _("Problem updating Category"));
 313 } else {
 314         gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAT_ENABLED, cat_enabled, -1);
 315 }
 316
 317 }
 318
 319 static gboolean
 320 category_add_cb(GtkWidget *widget, GtkWidget *tree_view)
 321 {
 322 GtkListStore *store;
 323
 324 if (poi_category_dialog(0)) {
 325         store = poi_category_generate_store();
 326         gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), GTK_TREE_MODEL(store));
 327         g_object_unref(G_OBJECT(store));
 328 }
 329 return TRUE;
 330 }
 331
 332 static gboolean
 333 category_edit_cb(GtkWidget *widget, GtkWidget *tree_view)
 334 {
 335 GtkTreeIter iter;
 336 GtkTreeModel *store;
 337 GtkTreeSelection *selection;
 338
 339 store = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 340 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 341 if (gtk_tree_selection_get_selected(selection, &store, &iter)) {
 342         GValue val;
 343         memset(&val, 0, sizeof(val));
 344         gtk_tree_model_get_value(store, &iter, 0, &val);
 345         if (poi_category_dialog(g_value_get_uint(&val))) {
 346                 GtkListStore *new_store = poi_category_generate_store();
 347                 gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), GTK_TREE_MODEL(new_store));
 348                 g_object_unref(G_OBJECT(new_store));
 349         }
 350 }
 351 return TRUE;
 352 }
 353
 354 gboolean
 355 poi_category_list()
 356 {
 357 GtkWidget *dialog;
 358 GtkWidget *tree_view;
 359 GtkWidget *sw;
 360 GtkWidget *btn_edit;
 361 GtkWidget *btn_add;
 362 GtkTreeViewColumn *column;
 363 GtkCellRenderer *renderer;
 364 GtkListStore *store;
 365
 366 dialog = gtk_dialog_new_with_buttons(_("POI Categories"),
 367                              GTK_WINDOW(_window),
 368                              GTK_DIALOG_MODAL, GTK_STOCK_CLOSE,
 369                              GTK_RESPONSE_ACCEPT, NULL);
 370
 371 help_dialog_help_enable(GTK_DIALOG(dialog), HELP_ID_POICAT);
 372
 373 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), btn_edit = gtk_button_new_with_label(_("Edit")));
 374 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), btn_add = gtk_button_new_with_label(_("Add")));
 375
 376 store=poi_category_generate_store();
 377
 378 if (!store)
 379         return TRUE;
 380
 381 sw=gtk_scrolled_window_new(NULL, NULL);
 382 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 383 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0);
 384
 385 tree_view=gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 386 #ifdef WITH_HILDON
 387 g_object_set(tree_view, "allow-checkbox-mode", FALSE, NULL);
 388 #endif
 389 gtk_container_add(GTK_CONTAINER(sw), tree_view);
 390
 391 gtk_tree_selection_set_mode(gtk_tree_view_get_selection (GTK_TREE_VIEW(tree_view)), GTK_SELECTION_SINGLE);
 392 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), TRUE);
 393
 394 renderer = gtk_cell_renderer_text_new();
 395 column = gtk_tree_view_column_new_with_attributes(_("ID"), renderer, "text", CAT_ID, NULL);
 396 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 397
 398 renderer = gtk_cell_renderer_toggle_new();
 399 g_signal_connect(renderer, "toggled", G_CALLBACK(category_toggled_cb), store);
 400 column = gtk_tree_view_column_new_with_attributes(_("Enabled"), renderer, "active", CAT_ENABLED, NULL);
 401 gtk_tree_view_column_set_max_width(column, 32);
 402 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 403 gtk_tree_view_column_set_sort_column_id (column, CAT_ENABLED);
 404
 405 g_object_unref(G_OBJECT(store));
 406
 407 renderer = gtk_cell_renderer_pixbuf_new();
 408 column = gtk_tree_view_column_new_with_attributes(_("Icon"), renderer, "pixbuf", CAT_ICON, NULL);
 409 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 410
 411 renderer = gtk_cell_renderer_text_new();
 412 column = gtk_tree_view_column_new_with_attributes(_("Label"), renderer, "text", CAT_LABEL, NULL);
 413 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 414 gtk_tree_view_column_set_sort_column_id (column, CAT_LABEL);
 415
 416 renderer = gtk_cell_renderer_text_new();
 417 column = gtk_tree_view_column_new_with_attributes(_("# POIs"), renderer, "text", CAT_POI_CNT, NULL);
 418 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 419 gtk_tree_view_column_set_sort_column_id (column, CAT_POI_CNT);
 420
 421 renderer = gtk_cell_renderer_text_new();
 422 g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 423 column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", CAT_DESC, NULL);
 424 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 425
 426 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 300);
 427
 428 g_signal_connect(G_OBJECT(btn_edit), "clicked", G_CALLBACK(category_edit_cb), tree_view);
 429 g_signal_connect(G_OBJECT(btn_add), "clicked", G_CALLBACK(category_add_cb), tree_view);
 430
 431 gtk_widget_show_all(dialog);
 432 gtk_dialog_run(GTK_DIALOG(dialog));
 433 gtk_widget_destroy(dialog);
 434
 435 return TRUE;
 436 }
 437
 438 gboolean
 439 poi_delete_confirm(GtkWidget *widget, delete_poi *dpoi)
 440 {
 441 GtkWidget *dialog;
 442 guint i;
 443 gchar *buffer;
 444
 445 buffer = g_strdup_printf("%s\n%s", _("Delete POI?"), dpoi->txt_label);
 446 dialog = hildon_note_new_confirmation(GTK_WINDOW(_window), buffer);
 447 g_free(buffer);
 448 i = gtk_dialog_run(GTK_DIALOG(dialog));
 449 gtk_widget_destroy(GTK_WIDGET(dialog));
 450
 451 if (i == GTK_RESPONSE_OK) {
 452         if (poi_delete(dpoi->id)==FALSE) {
 453                 popup_error(_window, _("Problem deleting POI"));
 454         } else {
 455                 gtk_widget_hide_all(dpoi->dialog);
 456                 map_poi_cache_clear();
 457                 map_force_redraw();
 458         }
 459 }
 460 return TRUE;
 461 }
 462
 463 static gboolean
 464 poi_search_do_cb(GtkWidget *widget, gpointer data)
 465 {
 466 gchar *s;
 467 guint cid;
 468 GtkListStore *store;
 469 GtkTreeIter iter;
 470 search_dialog *sd=(search_dialog *)data;
 471
 472 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(sd->cmb_category), &iter)==TRUE)
 473         gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(sd->cmb_category)), &iter, 0, &cid, -1);
 474 else
 475         cid=-1;
 476
 477 if ((strlen(gtk_entry_get_text(GTK_ENTRY(sd->search_entry)))<2) && (cid==-1)) {
 478         popup_error(sd->dialog, _("Query string too short. Minimum 2 characters."));
 479         return TRUE;
 480 }
 481
 482 s=g_strdup(gtk_entry_get_text(GTK_ENTRY(sd->search_entry)));
 483 g_printf("Search: [%s]\n", s);
 484
 485 #if 0
 486 store=gtk_tree_view_get_model(GTK_TREE_VIEW(sd->list));
 487 if (store) {
 488         gtk_list_store_clear(store);
 489         g_object_unref(G_OBJECT(store));
 490 }
 491 #endif
 492
 493 if (poi_search((cid==-1) ? POI_SEARCH_TEXT : POI_SEARCH_TEXT_CAT, sd->lat, sd->lon, s, cid, &sd->store)==TRUE) {
 494         gtk_tree_view_set_model(GTK_TREE_VIEW(sd->list), GTK_TREE_MODEL(sd->store));
 495         g_object_unref(G_OBJECT(sd->store));
 496 } else {
 497         sd->store=NULL;
 498         gtk_tree_view_set_model(GTK_TREE_VIEW(sd->list), GTK_TREE_MODEL(sd->store));
 499 }
 500
 501 g_free(s);
 502 return TRUE;
 503 }
 504
 505 static gboolean
 506 poi_goto_cb(GtkWidget *widget, gpointer data)
 507 {
 508 GtkTreeIter iter;
 509 GtkTreeModel *model;
 510 gdouble lat, lon;
 511 search_dialog *sd=(search_dialog *)data;
 512
 513 if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->list)), NULL, &iter)) {
 514         popup_error(sd->dialog, _("Select one POI from the list."));
 515         return TRUE;
 516 }
 517
 518 model=gtk_tree_view_get_model(GTK_TREE_VIEW(sd->list));
 519 if (!model)
 520         return TRUE;
 521
 522 gtk_tree_model_get(model, &iter, ITEM_LAT, &lat, -1);
 523 gtk_tree_model_get(model, &iter, ITEM_LON, &lon, -1);
 524
 525 map_center_latlon(lat, lon);
 526 map_update_location_from_center();
 527
 528 return TRUE;
 529 }
 530
 531 static gboolean
 532 poi_route_to_cb(GtkWidget *widget, gpointer data)
 533 {
 534 GtkTreeIter iter;
 535 GtkTreeModel *model;
 536 search_dialog *sd=(search_dialog *)data;
 537
 538 if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->list)), NULL, &iter)) {
 539         popup_error(sd->dialog, _("Select one POI from the list."));
 540         return TRUE;
 541 }
 542
 543 model=gtk_tree_view_get_model(GTK_TREE_VIEW(sd->list));
 544 if (!model)
 545         return TRUE;
 546
 547 _dest->valid=TRUE;
 548 gtk_tree_model_get(model, &iter, ITEM_LAT, &_dest->lat, -1);
 549 gtk_tree_model_get(model, &iter, ITEM_LON, &_dest->lon, -1);
 550
 551 map_update_location_from_center();
 552
 553 return TRUE;
 554 }
 555
 556 gboolean
 557 poi_search_dialog(GtkListStore *store, poi_info *poi, gdouble lat, gdouble lon)
 558 {
 559 GtkWidget *sw, *hbox, *label, *btn_search, *btn_goto, *btn_route_to;
 560 GtkTreeViewColumn *column;
 561 GtkCellRenderer *renderer;
 562 GtkTreeIter iter;
 563 gboolean selected = FALSE;
 564
 565 sd.dialog = gtk_dialog_new_with_buttons(_("Select POI"),
 566                         GTK_WINDOW(_window),
 567                         GTK_DIALOG_MODAL,
 568                         GTK_STOCK_OK,
 569                         GTK_RESPONSE_ACCEPT,
 570                         GTK_STOCK_CANCEL,
 571                         GTK_RESPONSE_REJECT, NULL);
 572 sd.lat=lat;
 573 sd.lon=lon;
 574
 575 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(sd.dialog)->action_area),
 576         btn_goto = gtk_button_new_with_label(_("Go")));
 577
 578 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(sd.dialog)->action_area),
 579         btn_route_to = gtk_button_new_with_label(_("Route to")));
 580
 581 gtk_window_set_default_size(GTK_WINDOW(sd.dialog), 500, 300);
 582
 583 hbox = gtk_hbox_new(FALSE, 4),
 584 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(sd.dialog)->vbox), hbox, FALSE, FALSE, 0);
 585
 586 label=gtk_label_new(_("Search:"));
 587 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 588
 589 sd.cmb_category = category_combo_new();
 590 gtk_box_pack_start(GTK_BOX(hbox), sd.cmb_category, FALSE, FALSE, 0);
 591 poi_category_combo_populate(sd.cmb_category, 0, TRUE);
 592
 593 sd.search_entry=gtk_entry_new();
 594 gtk_box_pack_start(GTK_BOX(hbox), sd.search_entry, TRUE, TRUE, 0);
 595
 596 btn_search=gtk_button_new_with_label(_("Search"));
 597 gtk_box_pack_start(GTK_BOX(hbox), btn_search, FALSE, FALSE, 0);
 598
 599 sw = gtk_scrolled_window_new(NULL, NULL);
 600 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 601 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 602 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(sd.dialog)->vbox), sw, TRUE, TRUE, 0);
 603
 604 if (store!=NULL) {
 605         sd.list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 606         sd.store=store;
 607         g_object_unref(G_OBJECT(store));
 608 } else {
 609         sd.list=gtk_tree_view_new();
 610         sd.store=NULL;
 611 }
 612 gtk_container_add(GTK_CONTAINER(sw), sd.list);
 613
 614 gtk_tree_selection_set_mode(gtk_tree_view_get_selection (GTK_TREE_VIEW(sd.list)), GTK_SELECTION_SINGLE);
 615 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(sd.list), TRUE);
 616 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(sd.list), TRUE);
 617 gtk_tree_view_set_search_column (GTK_TREE_VIEW(sd.list), ITEM_LABEL);
 618
 619 renderer = gtk_cell_renderer_text_new();
 620 column = gtk_tree_view_column_new_with_attributes(_("Location"), renderer, "text", ITEM_LATLON, NULL);
 621 gtk_tree_view_append_column(GTK_TREE_VIEW(sd.list), column);
 622
 623 renderer = gtk_cell_renderer_text_new();
 624 column = gtk_tree_view_column_new_with_attributes(_("Label"), renderer, "text", ITEM_LABEL, NULL);
 625 gtk_tree_view_column_set_sort_column_id (column, ITEM_LABEL);
 626 gtk_tree_view_append_column(GTK_TREE_VIEW(sd.list), column);
 627
 628 renderer = gtk_cell_renderer_text_new();
 629 column = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", ITEM_CATLAB, NULL);
 630 gtk_tree_view_column_set_sort_column_id (column, ITEM_CATLAB);
 631 gtk_tree_view_append_column(GTK_TREE_VIEW(sd.list), column);
 632
 633 g_signal_connect(G_OBJECT(btn_search), "clicked", G_CALLBACK(poi_search_do_cb), &sd);
 634 g_signal_connect(G_OBJECT(btn_goto), "clicked", G_CALLBACK(poi_goto_cb), &sd);
 635 g_signal_connect(G_OBJECT(btn_route_to), "clicked", G_CALLBACK(poi_route_to_cb), &sd);
 636
 637 gtk_widget_show_all(sd.dialog);
 638
 639 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(sd.dialog))) {
 640         if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(sd.list)), NULL, &iter)) {
 641                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_ID, &(poi->poi_id), -1);
 642                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_CATID, &(poi->cat_id), -1);
 643                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_LAT, &(poi->lat), -1);
 644                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_LON, &(poi->lon), -1);
 645                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_LABEL, &(poi->label), -1);
 646                 gtk_tree_model_get(GTK_TREE_MODEL(sd.store), &iter, ITEM_DESC, &(poi->desc), -1);
 647                 selected = TRUE;
 648                 break;
 649         } else {
 650                 popup_error(sd.dialog, _("Select one POI from the list."));
 651         }
 652 }
 653
 654 gtk_widget_destroy(sd.dialog);
 655 return selected;
 656 }
 657
 658 gboolean
 659 poi_select(guint unitx, guint unity, guint range, poi_info *poi)
 660 {
 661 GtkListStore *store;
 662 guint num_pois;
 663 GtkTreeIter iter;
 664 gdouble lat, lon, r;
 665
 666 r=pixel2unit(2*range);
 667 unit2latlon(unitx, unity, lat, lon);
 668
 669 store=poi_list_store_new();
 670 if (poi_get_list_near(lat, lon, r, store, &num_pois)==FALSE) {
 671         g_object_unref(G_OBJECT(store));
 672         return FALSE;
 673 }
 674
 675 switch (num_pois) {
 676 case 0:
 677         MACRO_BANNER_SHOW_INFO(_window, _("No POIs found."));
 678         g_object_unref(G_OBJECT(store));
 679         return FALSE;
 680 break;
 681 case 1:
 682         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
 683         gtk_tree_model_get(GTK_TREE_MODEL(store),
 684                         &iter,
 685                         ITEM_ID, &(poi->poi_id),
 686                         ITEM_CATID, &(poi->cat_id),
 687                         ITEM_LAT, &(poi->lat),
 688                         ITEM_LON, &(poi->lon),
 689                         ITEM_LABEL, &(poi->label),
 690                         ITEM_DESC, &(poi->desc), -1);
 691         g_object_unref(G_OBJECT(store));
 692         return TRUE;
 693 break;
 694 }
 695
 696 return poi_search_dialog(store, poi, lat, lon);
 697 }
 698
 699 gboolean
 700 poi_edit_cat(GtkWidget * widget, PoiCategoryEditInfo * data)
 701 {
 702 if (poi_category_list())
 703         poi_category_combo_populate(data->cmb_category, data->cat_id, FALSE);
 704 return TRUE;
 705 }
 706
 707 /**
 708  * Url click callback
 709  */
 710 static void
 711 poi_info_url_clicked_cb(GtkHTML *html, const gchar *url, gpointer data)
 712 {
 713 g_printf("URL: %s\n", url);
 714 #ifdef WITH_OSSO
 715 osso_rpc_run_with_defaults(_osso, "osso_browser",
 716         OSSO_BROWSER_OPEN_NEW_WINDOW_REQ, NULL,
 717         DBUS_TYPE_STRING, url, DBUS_TYPE_BOOLEAN, FALSE, DBUS_TYPE_INVALID);
 718 #else
 719 g_debug("Not yet implemented for !OSSO\n");
 720 #endif
 721 }
 722
 723
 724 /**
 725  * Callback to load requested url
 726  */
 727 static void
 728 poi_info_url_requested_cb(GtkHTML *html, const char *url, GtkHTMLStream *stream)
 729 {
 730 g_printf("URL: %s\n", url);
 731 gtk_html_stream_close(stream, GTK_HTML_STREAM_ERROR);
 732 }
 733
 734 static void
 735 poi_info_title_cb(GtkHTML *html, const gchar *title)
 736 {
 737 g_printf("Title: %s\n", title);
 738 }
 739
 740 #define WRITE_HTML(html, args...) \
 741         { gchar *ph; \
 742         ph=g_markup_printf_escaped(html, ##args); \
 743         gtk_html_write(GTK_HTML(info), s, ph, strlen(ph)); \
 744         g_free(ph); }
 745
 746 /**
 747  * Display a nice POI information dialog
 748  *
 749  */
 750 gboolean
 751 poi_info_dialog(GtkWidget *window, guint poi_id)
 752 {
 753 GtkWidget *dialog;
 754 GtkWidget *info;
 755 GtkWidget *sw;
 756 poi_info *p;
 757 GtkHTMLStream *s;
 758 gint ls;
 759
 760 p=poi_get_by_id(poi_id);
 761 if (!p) {
 762         g_debug("Requested info for POI %d that does not exist!\n", poi_id);
 763         return FALSE;
 764 }
 765
 766 dialog=gtk_dialog_new_with_buttons(_("POI"),
 767                         GTK_WINDOW(window), GTK_DIALOG_MODAL,
 768                         GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 769                         NULL);
 770
 771 /* XXX: Add edit button */
 772
 773 info=gtk_html_new();
 774 gtk_html_set_editable(GTK_HTML(info), FALSE);
 775 gtk_html_allow_selection(GTK_HTML(info), TRUE);
 776 sw=gtk_scrolled_window_new(NULL, NULL);
 777 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 778 gtk_container_add(GTK_CONTAINER(sw), info);
 779 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0);
 780
 781 g_signal_connect(G_OBJECT(info), "link_clicked", G_CALLBACK(poi_info_url_clicked_cb), NULL);
 782 g_signal_connect(G_OBJECT(info), "url_requested", G_CALLBACK(poi_info_url_requested_cb), NULL);
 783 g_signal_connect(G_OBJECT(info), "title_changed", G_CALLBACK(poi_info_title_cb), dialog);
 784
 785 s=gtk_html_begin(GTK_HTML(info));
 786 ls=strlen(p->label);
 787
 788 /* XXX: Format lat/lon according to settings */
 789
 790 WRITE_HTML("<html><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">" \
 791         "<head><title>POI - %s</title></head><body><b>%s (<i>%s</i>)</b><br/><table>" \
 792         "<tr><th align=\"left\">Location:</th><td>%.5f, %.5f</td></tr>",
 793         ls>0 ? p->label : _("(Unknown)"),
 794         ls>0 ? p->label : _("(Unknown)"), p->cat_label,
 795         p->lat, p->lon);
 796
 797 if (p->postal_code)
 798         WRITE_HTML("<tr><th align=\"left\">Postal Code:</th><td>%s</td></tr>", p->postal_code);
 799 if (p->url)
 800         WRITE_HTML("<tr><th align=\"left\">Link:</th><td><a href=\"%s\">%s</a></td></tr>", p->url, p->url);
 801 if (p->desc)
 802         WRITE_HTML("<tr><th align=\"left\" colspan=\"2\">Description:</th><td colspan=\"2\">%s</td></tr>", p->desc);
 803
 804 WRITE_HTML("</table><br/>");
 805
 806 # if 0
 807 if (p->image)
 808         WRITE_HTML("<img src=\"%s\">", p->image);
 809 #endif
 810
 811 WRITE_HTML("</body></html>");
 812 gtk_html_end(GTK_HTML(info), s, GTK_HTML_STREAM_OK);
 813
 814 poi_free(p);
 815
 816 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 250);
 817 gtk_widget_show_all(dialog);
 818 gtk_dialog_run(GTK_DIALOG(dialog));
 819 gtk_widget_destroy(dialog);
 820
 821 return TRUE;
 822 }
 823
 824 /**
 825  * poi_edit_dialog
 826  *
 827  * Edit or Add POI with given information in poi_info
 828  *
 829  */
 830 gboolean
 831 poi_edit_dialog(POIAction action, poi_info *poi)
 832 {
 833 gchar slat1[10], slon1[10];
 834 gchar *p_latlon;
 835 GtkWidget *dialog;
 836 GtkWidget *table;
 837 GtkWidget *label;
 838 GtkWidget *txt_label;
 839 GtkWidget *cmb_category;
 840 GtkWidget *txt_desc;
 841 GtkWidget *txt_postal_code, *txt_url;
 842 GtkWidget *btn_delete = NULL;
 843 GtkWidget *btn_catedit;
 844 GtkWidget *hbox;
 845 GtkWidget *txt_scroll;
 846 GtkTextBuffer *desc_txt;
 847 GtkTextIter begin, end;
 848 delete_poi dpoi = { NULL, NULL, 0 };
 849 PoiCategoryEditInfo pcedit;
 850 gchar tmp1[16], tmp2[16];
 851
 852 /* Fatal, poi must be set */
 853
 854 if (!poi)
 855         return FALSE;
 856
 857 dialog = gtk_dialog_new_with_buttons(action == ACTION_EDIT_POI ? _("Edit POI") : _("Add POI"),
 858                      GTK_WINDOW(_window),
 859                      GTK_DIALOG_MODAL,
 860                      GTK_STOCK_OK,
 861                      GTK_RESPONSE_ACCEPT,
 862                      GTK_STOCK_CANCEL,
 863                      GTK_RESPONSE_REJECT, NULL);
 864
 865 if (action == ACTION_EDIT_POI) {
 866         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), btn_delete = gtk_button_new_with_label(_("Delete")));
 867
 868         dpoi.dialog=dialog;
 869         dpoi.txt_label=g_strdup(poi->label);
 870         dpoi.id=poi->poi_id;
 871
 872         g_signal_connect(G_OBJECT(btn_delete), "clicked", G_CALLBACK(poi_delete_confirm), &dpoi);
 873 }
 874
 875 /* Set the p_latlon string. */
 876 lat_format(_degformat, poi->lat, tmp1);
 877 lon_format(_degformat, poi->lon, tmp2);
 878 p_latlon=g_strdup_printf("%s, %s", tmp1, tmp2);
 879
 880 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table = gtk_table_new(6, 4, FALSE), TRUE, TRUE, 0);
 881
 882 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Lat, Lon")), 0, 1, 0, 1, GTK_FILL, 0, 2, 4);
 883 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 884
 885 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(p_latlon), 1, 3, 0, 1, GTK_FILL, 0, 2, 4);
 886 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
 887
 888 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Label")), 0, 1, 1, 2, GTK_FILL, 0, 2, 4);
 889 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 890 gtk_table_attach(GTK_TABLE(table), txt_label = gtk_entry_new(), 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 891
 892 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Category")), 0, 1, 3, 4, GTK_FILL, 0, 2, 4);
 893 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 894 gtk_table_attach(GTK_TABLE(table), hbox = gtk_hbox_new(FALSE, 4), 1, 2, 3, 4, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 895
 896 gtk_box_pack_start(GTK_BOX(hbox), cmb_category = category_combo_new(), FALSE, FALSE, 4);
 897
 898 gtk_box_pack_start(GTK_BOX(hbox), btn_catedit = gtk_button_new_with_label(_("Edit Categories...")),     FALSE, FALSE, 4);
 899
 900 gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Description")), 0, 1, 5, 6, GTK_FILL, 0, 2, 4);
 901 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 902
 903 txt_scroll = gtk_scrolled_window_new(NULL, NULL);
 904 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scroll), GTK_SHADOW_IN);
 905 gtk_table_attach(GTK_TABLE(table), txt_scroll, 1, 2, 5, 6, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 906
 907 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 908
 909 txt_desc=gtk_text_view_new();
 910 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt_desc), GTK_WRAP_WORD);
 911
 912 gtk_container_add(GTK_CONTAINER(txt_scroll), txt_desc);
 913 gtk_widget_set_size_request(GTK_WIDGET(txt_scroll), 400, 60);
 914
 915 desc_txt=gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_desc));
 916
 917 /* label */
 918 if (poi->label)
 919         gtk_entry_set_text(GTK_ENTRY(txt_label), poi->label);
 920 if (poi->desc)
 921         gtk_text_buffer_set_text(desc_txt, poi->desc, -1);
 922
 923 poi_category_combo_populate(cmb_category, poi->cat_id, FALSE);
 924
 925 /* Connect Signals */
 926 pcedit.cmb_category=cmb_category;
 927 pcedit.cat_id=poi->cat_id;
 928
 929 g_signal_connect(G_OBJECT(btn_catedit), "clicked", G_CALLBACK(poi_edit_cat), &pcedit);
 930 gtk_widget_show_all(dialog);
 931
 932 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 933         GtkTreeIter iter;
 934
 935         if (strlen(gtk_entry_get_text(GTK_ENTRY(txt_label))))
 936                 poi->label=g_strdup(gtk_entry_get_text(GTK_ENTRY(txt_label)));
 937         else {
 938                 popup_error(dialog, _("Please specify a name for the POI."));
 939                 continue;
 940         }
 941
 942         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(cmb_category), &iter)) {
 943                 popup_error(dialog, _("Please specify a category for the POI."));
 944                 continue;
 945         }
 946
 947         gtk_text_buffer_get_bounds(desc_txt, &begin, &end);
 948         poi->desc=gtk_text_buffer_get_text(desc_txt, &begin, &end, TRUE);
 949
 950         gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(cmb_category)), &iter, 0, &poi->cat_id, -1);
 951
 952         if (action == ACTION_EDIT_POI) {
 953                 /* edit poi */
 954                 if (poi_update(poi)==FALSE) {
 955                         popup_error(_window, _("Problem updating POI"));
 956                 } else {
 957                         map_poi_cache_clear();
 958                         map_force_redraw();
 959                 }
 960         } else {
 961                 /* add poi */
 962                 g_ascii_dtostr(slat1, sizeof(slat1), poi->lat);
 963                 g_ascii_dtostr(slon1, sizeof(slon1), poi->lon);
 964                 if (poi_add(poi)==FALSE) {
 965                         popup_error(_window, _("Problem adding POI"));
 966                 } else {
 967                         map_poi_cache_clear();
 968                         map_force_redraw();
 969                 }
 970         }
 971         break;
 972 }
 973
 974 poi_free(poi);
 975 g_free(dpoi.txt_label);
 976 g_free(p_latlon);
 977
 978 gtk_widget_destroy(dialog);
 979
 980 return TRUE;
 981 }
 982
 983 static gboolean
 984 poi_quick_button_cb(GtkWidget *button, gpointer data)
 985 {
 986 poi_info *p;
 987 poi_quick_data *qpdata=(poi_quick_data *)data;
 988
 989 g_assert(data);
 990
 991 p=poi_new();
 992 p->cat_id=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "pid"));
 993
 994 if (strlen(gtk_entry_get_text(GTK_ENTRY(qpdata->label)))>0) {
 995         p->label=g_strdup(gtk_entry_get_text(GTK_ENTRY(qpdata->label)));
 996 } else {
 997         p->label=g_strdup("");
 998 }
 999
1000 if (qpdata->fixed==TRUE) {
1001         p->lat=qpdata->lat;
1002         p->lon=qpdata->lon;
1003 } else {
1004         p->lat=_gps->data.lat;
1005         p->lon=_gps->data.lon;
1006 }
1007 p->desc=g_strdup("Quick POI, update information please.");
1008
1009 /* poi_add frees the label and desc so strdup */
1010 if (poi_add(p)==FALSE) {
1011         popup_error(_window, _("Problem adding POI"));
1012 } else {
1013         gchar *txt;
1014
1015         map_poi_cache_clear();
1016
1017         /* Add a text break to the current track */
1018         /* XXX: Get category string in here if label is empty */
1019         txt=g_strdup_printf("QP(%d): %f %f %s", p->cat_id, p->lat, p->lon, p->label);
1020         path_insert_mark_text(_track, txt);
1021
1022         map_force_redraw();
1023         if (qpdata->close==TRUE)
1024                 gtk_widget_destroy(qpdata->dialog);
1025
1026         hildon_banner_show_information(_window, NULL, _("POI added"));
1027 }
1028
1029 poi_free(p);
1030 return TRUE;
1031 }
1032
1033 static void
1034 poi_button_set_icon(GtkWidget *button, node_type_t t)
1035 {
1036 const gchar *iname;
1037 GdkPixbuf *icon=NULL;
1038
1039 iname=poi_get_icon_from_type(t);
1040 if (iname)
1041         icon=poi_get_icon(iname, TRUE);
1042 if (icon) {
1043         g_debug("Got button icon %s", iname);
1044         gtk_button_set_image(GTK_BUTTON(button), gtk_image_new_from_pixbuf(icon));
1045 #if GTK_CHECK_VERSION(2,10,0)
1046         gtk_button_set_image_position(GTK_BUTTON(button), GTK_POS_TOP);
1047 #endif
1048 } else {
1049         g_debug("No button icon for %s", iname);
1050 }
1051 }
1052
1053 /**
1054  * Return a vbox filled with POI_QUICK_BUTTONS POI buttons and one for other POI,
1055  * with an optinal POI label.
1056  */
1057 GtkWidget *
1058 poi_quick_button_box(poi_quick_data *qpdata)
1059 {
1060 GtkWidget *table, *vbox;
1061 GtkWidget *buttons[POI_QUICK_BUTTONS];
1062 GtkWidget *otherbtn;
1063 guint x, y;
1064
1065 vbox=gtk_vbox_new(FALSE, 6);
1066 table = gtk_table_new(QPBS_Y, QPBS_X, TRUE);
1067 gtk_table_set_col_spacings(GTK_TABLE(table), 6);
1068 gtk_table_set_row_spacings(GTK_TABLE(table), 6);
1069
1070 for (y=0;y<QPBS_Y;y++) {
1071         for (x=0;x<QPBS_X;x++) {
1072                 guint p=y*(QPBS_X)+x;
1073
1074                 g_debug("B: %d (%d,%d)", p, x, y);
1075                 buttons[p]=gtk_button_new_with_label(quick_poi_categories[p].name);
1076                 poi_button_set_icon(buttons[p], quick_poi_categories[p].type);
1077                 gtk_table_attach(GTK_TABLE(table), buttons[p], x, x+1, y, y+1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 6, 6);
1078                 g_object_set_data(G_OBJECT(buttons[p]), "pid", GINT_TO_POINTER(quick_poi_categories[p].type));
1079                 g_signal_connect(G_OBJECT(buttons[p]), "clicked", G_CALLBACK(poi_quick_button_cb), qpdata);
1080         }
1081 }
1082
1083 gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
1084
1085 /* Other POI button */
1086 otherbtn=gtk_button_new_with_label("Other POI");
1087 poi_button_set_icon(otherbtn, NODE_AMENITY_GENERIC);
1088 gtk_box_pack_start(GTK_BOX(vbox), otherbtn, TRUE, FALSE, 6);
1089 g_object_set_data(G_OBJECT(otherbtn), "pid", GINT_TO_POINTER(NODE_AMENITY_GENERIC));
1090 g_signal_connect(G_OBJECT(otherbtn), "clicked", G_CALLBACK(poi_quick_button_cb), qpdata);
1091
1092 gtk_box_pack_start(GTK_BOX(vbox), qpdata->label = gtk_entry_new(), TRUE, FALSE, 0);
1093
1094 return vbox;
1095 }
1096
1097 /**
1098  * Show simple dialog for adding a POI.
1099  * Uses the above helper to get the buttons. The location is given as paramters.
1100  */
1101 gboolean
1102 poi_quick_dialog(gdouble lat, gdouble lon)
1103 {
1104 GtkWidget *box;
1105
1106 qp.dialog=gtk_dialog_new_with_buttons(_("Quick POI"),
1107                 GTK_WINDOW(_window),
1108                     GTK_DIALOG_MODAL,
1109                         GTK_STOCK_CANCEL,
1110                         GTK_RESPONSE_REJECT,
1111                         NULL);
1112
1113 help_dialog_help_enable(GTK_DIALOG(qp.dialog), HELP_ID_POIQUICK);
1114
1115 qp.fixed=TRUE;
1116 qp.lat=lat;
1117 qp.lon=lon;
1118 qp.close=TRUE;
1119
1120 box=poi_quick_button_box(&qp);
1121 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(qp.dialog)->vbox), box, TRUE, TRUE, 0);
1122
1123 gtk_widget_show_all(qp.dialog);
1124
1125 if (gtk_dialog_run(GTK_DIALOG(qp.dialog))==GTK_RESPONSE_REJECT)
1126         gtk_widget_destroy(qp.dialog);
1127
1128 return TRUE;
1129 }