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