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

   1 #include <config.h>
   2
   3 #define _GNU_SOURCE
   4
   5 #include <unistd.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <strings.h>
   9 #include <stddef.h>
  10 #include <locale.h>
  11 #include <math.h>
  12 #include <errno.h>
  13 #include <sys/wait.h>
  14 #include <glib/gstdio.h>
  15 #include <gtk/gtk.h>
  16 #include <fcntl.h>
  17 #include <libintl.h>
  18 #include <locale.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 "ui-common.h"
  26 #include "settings.h"
  27 #include "poi-gui.h"
  28 #include "osm.h"
  29
  30 #define POI_QUICK_BUTTONS (9)
  31
  32 static GtkWidget *dialog_qp;
  33
  34 typedef struct _PoiCategoryEditInfo PoiCategoryEditInfo;
  35 struct _PoiCategoryEditInfo {
  36         GtkWidget *cmb_category;
  37         guint cat_id;
  38 };
  39
  40 /* XXX: Load this from somewhere instead of hc... */
  41 struct _quick_poi_categories {
  42     node_type_t type;
  43     const gchar *name;
  44 };
  45
  46 static struct _quick_poi_categories quick_poi_categories[] = {
  47         { NODE_AMENITY_SPEEDCAM,        "Speedcam", },
  48         { NODE_AMENITY_FUEL,            "Fuel", },
  49         { NODE_AMENITY_PARKING,         "Parking", },
  50
  51         { NODE_AMENITY_PUB,             "Pub", },
  52         { NODE_AMENITY_CAFE,            "Cafe", },
  53         { NODE_AMENITY_FOOD,            "Food", },
  54
  55         { NODE_AMENITY_SHOP,            "Shop", },
  56         { NODE_AMENITY_BANK,            "Bank", },
  57         { NODE_AMENITY_ATM,             "ATM", },
  58 };
  59
  60
  61 static gboolean
  62 category_delete(GtkWidget *widget, delete_poi *dpoi)
  63 {
  64         GtkWidget *dialog;
  65         guint i;
  66         gchar *buffer;
  67
  68         buffer = g_strdup_printf("%s\n\t%s\n%s", _("Delete category?"),
  69                                  dpoi->txt_label, _("WARNING: All POIs in that category will also be deleted!"));
  70         dialog = hildon_note_new_confirmation(GTK_WINDOW(_window), buffer);
  71         g_free(buffer);
  72         i = gtk_dialog_run(GTK_DIALOG(dialog));
  73         gtk_widget_destroy(GTK_WIDGET(dialog));
  74
  75         if (i == GTK_RESPONSE_OK) {
  76                 if (poi_category_delete(dpoi)==FALSE)
  77                         popup_error(_window, _("Problem deleting category or POI"));
  78                 gtk_widget_hide_all(dpoi->dialog);
  79                 map_force_redraw();
  80         }
  81
  82         return TRUE;
  83 }
  84
  85 gboolean
  86 category_dialog(guint cat_id)
  87 {
  88         GtkWidget *dialog;
  89         GtkWidget *table;
  90         GtkWidget *label;
  91         GtkWidget *txt_label;
  92         GtkWidget *txt_desc;
  93         GtkWidget *btn_delete = NULL;
  94         GtkWidget *txt_scroll;
  95         GtkWidget *chk_enabled;
  96         GtkTextBuffer *desc_txt;
  97         GtkTextIter begin, end;
  98         gboolean results = TRUE;
  99         delete_poi dpoi = { NULL, NULL, 0 };
 100         poi_category *c;
 101
 102
 103         if (cat_id > 0) {
 104                 if (poi_category_get(cat_id, &c)==FALSE)
 105                         return FALSE;
 106
 107                 dialog = gtk_dialog_new_with_buttons(_("Edit Category"),
 108                                                      GTK_WINDOW(_window),
 109                                                      GTK_DIALOG_MODAL,
 110                                                      GTK_STOCK_OK,
 111                                                      GTK_RESPONSE_ACCEPT, NULL);
 112
 113                 gtk_container_add(GTK_CONTAINER
 114                                   (GTK_DIALOG(dialog)->action_area),
 115                                   btn_delete = gtk_button_new_with_label(_("Delete")));
 116
 117                 dpoi.dialog = dialog;
 118                 dpoi.txt_label = g_strdup(c->label);
 119                 dpoi.id = c->id;
 120
 121                 g_signal_connect(G_OBJECT(btn_delete), "clicked", G_CALLBACK(category_delete), &dpoi);
 122
 123                 gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
 124         } else {
 125                 c=poi_category_new();
 126                 c->enabled = 1;
 127                 c->label = g_strdup("");
 128                 c->id = 0;
 129                 c->desc = g_strdup("");
 130
 131                 dialog = gtk_dialog_new_with_buttons(_("Add Category"),
 132                                                      GTK_WINDOW(_window),
 133                                                      GTK_DIALOG_MODAL,
 134                                                      GTK_STOCK_OK,
 135                                                      GTK_RESPONSE_ACCEPT,
 136                                                      GTK_STOCK_CANCEL,
 137                                                      GTK_RESPONSE_REJECT, NULL);
 138         }
 139
 140         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
 141                            table = gtk_table_new(6, 4, FALSE), TRUE, TRUE, 0);
 142
 143         gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Label")),
 144                          0, 1, 0, 1, GTK_FILL, 0, 2, 4);
 145         gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 146         gtk_table_attach(GTK_TABLE(table),
 147                          txt_label = gtk_entry_new(),
 148                          1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 149
 150         gtk_table_attach(GTK_TABLE(table), label = gtk_label_new(_("Description")),
 151                          0, 1, 1, 2, GTK_FILL, 0, 2, 4);
 152         gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 153
 154         txt_scroll = gtk_scrolled_window_new(NULL, NULL);
 155         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scroll), GTK_SHADOW_IN);
 156         gtk_table_attach(GTK_TABLE(table),
 157                          txt_scroll, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 158
 159         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scroll),
 160                                        GTK_POLICY_AUTOMATIC,
 161                                        GTK_POLICY_AUTOMATIC);
 162
 163         txt_desc = gtk_text_view_new();
 164         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt_desc), GTK_WRAP_WORD);
 165
 166         gtk_container_add(GTK_CONTAINER(txt_scroll), txt_desc);
 167         gtk_widget_set_size_request(GTK_WIDGET(txt_scroll), 400, 60);
 168
 169         desc_txt = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_desc));
 170
 171         gtk_table_attach(GTK_TABLE(table),
 172                          chk_enabled = gtk_check_button_new_with_label(_("Enabled")), 0, 2, 2,
 173                          3, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 174
 175         /* label */
 176         gtk_entry_set_text(GTK_ENTRY(txt_label), c->label);
 177
 178         /* desc */
 179         gtk_text_buffer_set_text(desc_txt, c->desc, -1);
 180
 181         /* enabled */
 182         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk_enabled), (c->enabled == 1 ? TRUE : FALSE));
 183
 184         poi_category_free(c);
 185
 186         gtk_widget_show_all(dialog);
 187
 188         while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 189                 if (strlen(gtk_entry_get_text(GTK_ENTRY(txt_label)))) {
 190                         c=poi_category_new();
 191                         c->label = g_strdup(gtk_entry_get_text(GTK_ENTRY(txt_label)));
 192                 } else {
 193                         popup_error(dialog,_("Please specify a name for the category."));
 194                         continue;
 195                 }
 196
 197                 gtk_text_buffer_get_iter_at_offset(desc_txt, &begin, 0);
 198                 gtk_text_buffer_get_end_iter(desc_txt, &end);
 199                 c->desc = gtk_text_buffer_get_text(desc_txt, &begin, &end, TRUE);
 200                 c->enabled = (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(chk_enabled)) ? 1 : 0);
 201
 202                 results=poi_category_update(cat_id, c);
 203
 204                 if (results==FALSE)
 205                         popup_error(_window, _("Problem updating category"));
 206                 poi_category_free(c);
 207         }
 208
 209         g_free(dpoi.txt_label);
 210         g_object_unref(desc_txt);
 211         gtk_widget_hide_all(dialog);
 212
 213         return results;
 214 }
 215
 216 static void
 217 category_toggled(GtkCellRendererToggle * cell, gchar * path, gpointer data)
 218 {
 219         GtkTreeIter iter;
 220         gboolean cat_enabled;
 221         guint cat_id;
 222
 223         GtkTreeModel *model = GTK_TREE_MODEL(data);
 224         if (!gtk_tree_model_get_iter_from_string(model, &iter, path))
 225                 return;
 226
 227         gtk_tree_model_get(model, &iter, CAT_ENABLED, &cat_enabled, -1);
 228         gtk_tree_model_get(model, &iter, CAT_ID, &cat_id, -1);
 229
 230         cat_enabled ^= 1;
 231
 232         if (poi_category_toggle(cat_id, cat_enabled)==FALSE) {
 233                 popup_error(_window, _("Problem updating Category"));
 234         } else {
 235                 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAT_ENABLED, cat_enabled, -1);
 236         }
 237
 238 }
 239
 240 static gboolean
 241 category_add(GtkWidget * widget, GtkWidget * tree_view)
 242 {
 243         GtkListStore *store;
 244
 245         if (category_dialog(0)) {
 246                 store = poi_category_generate_store();
 247                 gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view),
 248                                         GTK_TREE_MODEL(store));
 249                 g_object_unref(G_OBJECT(store));
 250         }
 251         return TRUE;
 252 }
 253
 254 static gboolean
 255 category_edit(GtkWidget * widget, GtkWidget * tree_view)
 256 {
 257         GtkTreeIter iter;
 258         GtkTreeModel *store;
 259         GtkTreeSelection *selection;
 260
 261         store = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 262         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 263         if (gtk_tree_selection_get_selected(selection, &store, &iter)) {
 264                 GValue val;
 265                 memset(&val, 0, sizeof(val));
 266                 gtk_tree_model_get_value(store, &iter, 0, &val);
 267                 if (category_dialog(g_value_get_uint(&val))) {
 268                         GtkListStore *new_store = poi_category_generate_store();
 269                         gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view),
 270                                                 GTK_TREE_MODEL(new_store));
 271                         g_object_unref(G_OBJECT(new_store));
 272                 }
 273         }
 274         return TRUE;
 275 }
 276
 277 gboolean
 278 category_list()
 279 {
 280         GtkWidget *dialog;
 281         GtkWidget *tree_view;
 282         GtkWidget *sw;
 283         GtkWidget *btn_edit;
 284         GtkWidget *btn_add;
 285         GtkTreeViewColumn *column;
 286         GtkCellRenderer *renderer;
 287         GtkListStore *store;
 288
 289         dialog = gtk_dialog_new_with_buttons(_("POI Categories"),
 290                                              GTK_WINDOW(_window),
 291                                              GTK_DIALOG_MODAL, GTK_STOCK_OK,
 292                                              GTK_RESPONSE_ACCEPT, NULL);
 293
 294 #ifdef WITH_OSSO
 295         /* Enable the help button. */
 296         ossohelp_dialog_help_enable(GTK_DIALOG(dialog), HELP_ID_POICAT, _osso);
 297 #endif
 298
 299         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
 300                           btn_edit = gtk_button_new_with_label(_("Edit")));
 301
 302         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
 303                           btn_add = gtk_button_new_with_label(_("Add")));
 304
 305         store = poi_category_generate_store();
 306
 307         if (!store)
 308                 return TRUE;
 309
 310         sw = gtk_scrolled_window_new(NULL, NULL);
 311         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 312         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0);
 313
 314         tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 315         /* Maemo-related? */
 316         g_object_set(tree_view, "allow-checkbox-mode", FALSE, NULL);
 317         gtk_container_add(GTK_CONTAINER(sw), tree_view);
 318
 319         gtk_tree_selection_set_mode(gtk_tree_view_get_selection (GTK_TREE_VIEW(tree_view)), GTK_SELECTION_SINGLE);
 320         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), TRUE);
 321
 322         renderer = gtk_cell_renderer_text_new();
 323         column = gtk_tree_view_column_new_with_attributes(_("ID"), renderer, "text", CAT_ID, NULL);
 324         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 325         gtk_tree_view_column_set_max_width(column, 1);
 326
 327         renderer = gtk_cell_renderer_toggle_new();
 328         g_signal_connect(renderer, "toggled", G_CALLBACK(category_toggled), store);
 329         column = gtk_tree_view_column_new_with_attributes(_("Enabled"), renderer, "active", CAT_ENABLED, NULL);
 330         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 331         gtk_tree_view_column_set_sort_column_id (column, CAT_ENABLED);
 332
 333         g_object_unref(G_OBJECT(store));
 334
 335         renderer = gtk_cell_renderer_text_new();
 336         column = gtk_tree_view_column_new_with_attributes(_("Label"), renderer, "text", CAT_LABEL, NULL);
 337         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 338         gtk_tree_view_column_set_sort_column_id (column, CAT_LABEL);
 339
 340         renderer = gtk_cell_renderer_text_new();
 341         column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", CAT_DESC, NULL);
 342         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 343
 344         renderer = gtk_cell_renderer_text_new();
 345         column = gtk_tree_view_column_new_with_attributes(_("# POIs"), renderer, "text", CAT_POI_CNT, NULL);
 346         gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 347         gtk_tree_view_column_set_sort_column_id (column, CAT_POI_CNT);
 348
 349         gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 300);
 350
 351         g_signal_connect(G_OBJECT(btn_edit), "clicked", G_CALLBACK(category_edit), tree_view);
 352         g_signal_connect(G_OBJECT(btn_add), "clicked", G_CALLBACK(category_add), tree_view);
 353
 354         gtk_widget_show_all(dialog);
 355         while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 356                 break;
 357         }
 358         gtk_widget_destroy(dialog);
 359
 360         return TRUE;
 361 }
 362
 363 gboolean
 364 poi_delete_confirm(GtkWidget * widget, delete_poi * dpoi)
 365 {
 366 GtkWidget *dialog;
 367 guint i;
 368 gchar *buffer;
 369
 370 buffer = g_strdup_printf("%s\n%s", _("Delete POI?"), dpoi->txt_label);
 371 dialog = hildon_note_new_confirmation(GTK_WINDOW(_window), buffer);
 372 g_free(buffer);
 373 i = gtk_dialog_run(GTK_DIALOG(dialog));
 374 gtk_widget_destroy(GTK_WIDGET(dialog));
 375
 376 if (i == GTK_RESPONSE_OK) {
 377         if (poi_delete(dpoi)==FALSE) {
 378                 popup_error(_window, _("Problem deleting POI"));
 379         } else {
 380                 gtk_widget_hide_all(dpoi->dialog);
 381                 map_force_redraw();
 382         }
 383 }
 384 return TRUE;
 385 }
 386
 387 gboolean
 388 poi_search_dialog(GtkListStore *store, poi_info *poi)
 389 {
 390 GtkWidget *dialog, *list, *sw;
 391 GtkWidget *hbox, *label, *search_entry;
 392 GtkTreeViewColumn *column;
 393 GtkCellRenderer *renderer;
 394 GtkTreeIter iter;
 395 gboolean selected = FALSE;
 396
 397 dialog = gtk_dialog_new_with_buttons(_("Select POI"),
 398                         GTK_WINDOW(_window),
 399                         GTK_DIALOG_MODAL, GTK_STOCK_OK,
 400                         GTK_RESPONSE_ACCEPT,
 401                         GTK_STOCK_CANCEL,
 402                         GTK_RESPONSE_REJECT, NULL);
 403
 404 gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 300);
 405
 406 hbox = gtk_hbox_new(FALSE, 4),
 407 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0);
 408
 409 label=gtk_label_new(_("Search:"));
 410 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 411
 412 search_entry=gtk_entry_new();
 413 gtk_box_pack_start(GTK_BOX(hbox), search_entry, TRUE, TRUE, 0);
 414
 415 sw = gtk_scrolled_window_new(NULL, NULL);
 416 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 417 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 418 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), sw, TRUE, TRUE, 0);
 419
 420 list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 421 gtk_container_add(GTK_CONTAINER(sw), list);
 422 g_object_unref(G_OBJECT(store));
 423
 424 gtk_tree_selection_set_mode(gtk_tree_view_get_selection (GTK_TREE_VIEW(list)), GTK_SELECTION_SINGLE);
 425 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), TRUE);
 426 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), TRUE);
 427 gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), POI_LABEL);
 428
 429 renderer = gtk_cell_renderer_text_new();
 430 column = gtk_tree_view_column_new_with_attributes(_("Location"), renderer, "text", POI_LATLON, NULL);
 431 gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
 432
 433 renderer = gtk_cell_renderer_text_new();
 434 column = gtk_tree_view_column_new_with_attributes(_("Label"), renderer, "text", POI_LABEL, NULL);
 435 gtk_tree_view_column_set_sort_column_id (column, POI_LABEL);
 436 gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
 437
 438 renderer = gtk_cell_renderer_text_new();
 439 column = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", POI_CATLAB, NULL);
 440 gtk_tree_view_column_set_sort_column_id (column, POI_CATLAB);
 441 gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
 442
 443 gtk_widget_show_all(dialog);
 444
 445 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 446         if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(list)), NULL, &iter)) {
 447                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_POIID, &(poi->poi_id), -1);
 448                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_CATID, &(poi->cat_id), -1);
 449                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_LAT, &(poi->lat), -1);
 450                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_LON, &(poi->lon), -1);
 451                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_LABEL, &(poi->label), -1);
 452                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, POI_DESC, &(poi->desc), -1);
 453                 selected = TRUE;
 454                 break;
 455         } else {
 456                 popup_error(dialog, _("Select one POI from the list."));
 457         }
 458 }
 459
 460 gtk_widget_destroy(dialog);
 461 return selected;
 462 }
 463
 464 gboolean
 465 poi_select(guint unitx, guint unity, poi_info *poi)
 466 {
 467 GtkListStore *store;
 468 guint num_cats;
 469 GtkTreeIter iter;
 470
 471 if (poi_get_list(unitx, unity, &store, &num_cats)==FALSE)
 472         return FALSE;
 473
 474 switch (num_cats) {
 475 case 0:
 476         MACRO_BANNER_SHOW_INFO(_window, _("No POIs found."));
 477         g_object_unref(G_OBJECT(store));
 478         return FALSE;
 479         break;
 480 case 1:
 481         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
 482         gtk_tree_model_get(GTK_TREE_MODEL(store),
 483                         &iter,
 484                         POI_POIID, &(poi->poi_id),
 485                         POI_CATID, &(poi->cat_id),
 486                         POI_LAT, &(poi->lat),
 487                         POI_LON, &(poi->lon),
 488                         POI_LABEL, &(poi->label),
 489                         POI_DESC, &(poi->desc), -1);
 490         g_object_unref(G_OBJECT(store));
 491         return TRUE;
 492 break;
 493 }
 494
 495 return poi_search_dialog(store, poi);
 496 }
 497
 498 static void
 499 poi_populate_cat_combo(GtkWidget * cmb_category, guint cat_id)
 500 {
 501 GtkTreeIter active;
 502 GtkListStore *store;
 503 gboolean has_active = FALSE;
 504
 505 store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(cmb_category)));
 506 gtk_list_store_clear(store);
 507
 508 while (SQLITE_ROW == sqlite3_step(poisql.selall_cat)) {
 509         GtkTreeIter iter;
 510         guint cid = sqlite3_column_int(poisql.selall_cat, 0);
 511         gtk_list_store_append(store, &iter);
 512         gtk_list_store_set(store, &iter, 0, cid, 1, sqlite3_column_text(poisql.selall_cat, 1), -1);
 513         if (cid == cat_id) {
 514                 active = iter;
 515                 has_active = TRUE;
 516         }
 517 }
 518 sqlite3_reset(poisql.selall_cat);
 519
 520 if (!has_active)
 521         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &active);
 522
 523 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(cmb_category), &active);
 524 }
 525
 526 gboolean
 527 poi_edit_cat(GtkWidget * widget, PoiCategoryEditInfo * data)
 528 {
 529 if (category_list())
 530         poi_populate_cat_combo(data->cmb_category, data->cat_id);
 531 return TRUE;
 532 }
 533
 534 gboolean
 535 poi_dialog(POIAction action, guint unitx, guint unity)
 536 {
 537 poi_info poi;
 538 gchar slat1[10], slon1[10];
 539 gchar *p_latlon;
 540 GtkWidget *dialog;
 541 GtkWidget *table;
 542 GtkWidget *label;
 543 GtkWidget *txt_label;
 544 GtkWidget *cmb_category;
 545 GtkWidget *txt_desc;
 546 GtkWidget *btn_delete = NULL;
 547 GtkWidget *btn_catedit;
 548 GtkWidget *hbox;
 549 GtkWidget *txt_scroll;
 550 GtkTextBuffer *desc_txt;
 551 GtkTextIter begin, end;
 552 delete_poi dpoi = { NULL, NULL, 0 };
 553 PoiCategoryEditInfo pcedit;
 554
 555 if (action == ACTION_EDIT_POI) {
 556         if (!poi_select(unitx, unity, &poi)) {
 557                 return FALSE;
 558         }
 559
 560         dialog = gtk_dialog_new_with_buttons(_("Edit POI"),
 561                                              GTK_WINDOW(_window),
 562                                              GTK_DIALOG_MODAL,
 563                                              GTK_STOCK_OK,
 564                                              GTK_RESPONSE_ACCEPT, NULL);
 565         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
 566                           btn_delete = gtk_button_new_with_label(_("Delete")));
 567
 568         dpoi.dialog = dialog;
 569         dpoi.txt_label = g_strdup(poi.label);
 570         dpoi.id = poi.poi_id;
 571
 572         g_signal_connect(G_OBJECT(btn_delete), "clicked", G_CALLBACK(poi_delete_confirm), &dpoi);
 573
 574         gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
 575 } else {
 576         unit2latlon(unitx, unity, poi.lat, poi.lon);
 577
 578         poi.poi_id = 0;
 579         poi.cat_id = 0;
 580         poi.desc = g_strdup("");
 581         poi.label = g_strdup("");
 582
 583         dialog = gtk_dialog_new_with_buttons(_("Add POI"),
 584                                      GTK_WINDOW(_window),
 585                                      GTK_DIALOG_MODAL,
 586                                      GTK_STOCK_OK,
 587                                      GTK_RESPONSE_ACCEPT,
 588                                      GTK_STOCK_CANCEL,
 589                                      GTK_RESPONSE_REJECT, NULL);
 590 }
 591
 592 /* Set the p_latlon string. */
 593 {
 594         gchar tmp1[16], tmp2[16];
 595         lat_format(poi.lat, tmp1);
 596         lon_format(poi.lon, tmp2);
 597         p_latlon = g_strdup_printf("%s, %s", tmp1, tmp2);
 598 }
 599
 600 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
 601    table = gtk_table_new(6, 4, FALSE), TRUE, TRUE, 0);
 602
 603 gtk_table_attach(GTK_TABLE(table),
 604          label = gtk_label_new(_("Lat, Lon")),
 605          0, 1, 0, 1, GTK_FILL, 0, 2, 4);
 606 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 607
 608 gtk_table_attach(GTK_TABLE(table),
 609          label = gtk_label_new(p_latlon),
 610          1, 3, 0, 1, GTK_FILL, 0, 2, 4);
 611 gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
 612
 613 gtk_table_attach(GTK_TABLE(table),
 614          label = gtk_label_new(_("Label")),
 615          0, 1, 1, 2, GTK_FILL, 0, 2, 4);
 616 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 617 gtk_table_attach(GTK_TABLE(table),
 618          txt_label = gtk_entry_new(),
 619          1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 620
 621 gtk_table_attach(GTK_TABLE(table),
 622          label = gtk_label_new(_("Category")),
 623          0, 1, 3, 4, GTK_FILL, 0, 2, 4);
 624 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 625 gtk_table_attach(GTK_TABLE(table),
 626          hbox = gtk_hbox_new(FALSE, 4),
 627          1, 2, 3, 4, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 628
 629 /* Category ID, Label */
 630 cmb_category = gtk_combo_box_new_with_model(GTK_TREE_MODEL(gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING)));
 631 gtk_box_pack_start(GTK_BOX(hbox), cmb_category, FALSE, FALSE, 4);
 632
 633 /* Set up the view for the combo box. */
 634 {
 635         GtkCellRenderer *renderer;
 636         renderer = gtk_cell_renderer_text_new();
 637         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cmb_category), renderer, TRUE);
 638         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cmb_category), renderer, "text", 1, NULL);
 639 }
 640
 641 gtk_box_pack_start(GTK_BOX(hbox),
 642         btn_catedit = gtk_button_new_with_label(_("Edit Categories...")),
 643         FALSE, FALSE, 4);
 644
 645 gtk_table_attach(GTK_TABLE(table),
 646         label = gtk_label_new(_("Description")),
 647         0, 1, 5, 6, GTK_FILL, 0, 2, 4);
 648 gtk_misc_set_alignment(GTK_MISC(label), 1.f, 0.5f);
 649
 650 txt_scroll = gtk_scrolled_window_new(NULL, NULL);
 651 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scroll), GTK_SHADOW_IN);
 652 gtk_table_attach(GTK_TABLE(table), txt_scroll, 1, 2, 5, 6, GTK_EXPAND | GTK_FILL, 0, 2, 4);
 653
 654 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 655
 656 txt_desc = gtk_text_view_new();
 657 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(txt_desc), GTK_WRAP_WORD);
 658
 659 gtk_container_add(GTK_CONTAINER(txt_scroll), txt_desc);
 660 gtk_widget_set_size_request(GTK_WIDGET(txt_scroll), 400, 60);
 661
 662 desc_txt = gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt_desc));
 663
 664 /* label */
 665 gtk_entry_set_text(GTK_ENTRY(txt_label), poi.label);
 666
 667 /* category */
 668 poi_populate_cat_combo(cmb_category, poi.cat_id);
 669
 670 /* poi_desc */
 671 gtk_text_buffer_set_text(desc_txt, poi.desc, -1);
 672
 673 /* Connect Signals */
 674 pcedit.cmb_category = cmb_category;
 675 pcedit.cat_id = poi.cat_id;
 676 g_signal_connect(G_OBJECT(btn_catedit), "clicked", G_CALLBACK(poi_edit_cat), &pcedit);
 677 gtk_widget_show_all(dialog);
 678
 679 while (GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(dialog))) {
 680         gchar *poi_label = NULL;
 681         gchar *poi_desc = NULL;
 682         GtkTreeIter iter;
 683
 684         if (strlen(gtk_entry_get_text(GTK_ENTRY(txt_label))))
 685                 poi_label = gtk_entry_get_text(GTK_ENTRY(txt_label));
 686         else {
 687                 popup_error(dialog, _("Please specify a name for the POI."));
 688                 continue;
 689         }
 690
 691         if (!gtk_combo_box_get_active_iter
 692             (GTK_COMBO_BOX(cmb_category), &iter)) {
 693                 popup_error(dialog, _("Please specify a category for the POI."));
 694                 continue;
 695         }
 696
 697         gtk_text_buffer_get_iter_at_offset(desc_txt, &begin, 0);
 698         gtk_text_buffer_get_end_iter(desc_txt, &end);
 699         poi_desc = gtk_text_buffer_get_text(desc_txt, &begin, &end, TRUE);
 700
 701         gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(cmb_category)), &iter, 0, &poi.cat_id, -1);
 702
 703         if (action == ACTION_EDIT_POI) {
 704                 /* edit poi */
 705                 if (poi_update(poi.poi_id, poi.cat_id, poi_label, poi_desc)==FALSE) {
 706                         popup_error(_window, _("Problem updating POI"));
 707                 } else {
 708                         map_render_data();
 709                 }
 710         } else {
 711                 /* add poi */
 712                 g_ascii_dtostr(slat1, sizeof(slat1), poi.lat);
 713                 g_ascii_dtostr(slon1, sizeof(slon1), poi.lon);
 714                 if (poi_add(poi.lat, poi.lon, poi.cat_id, poi_label, poi_desc)==FALSE) {
 715                         popup_error(_window, _("Problem adding POI"));
 716                 } else {
 717                         map_render_data();
 718                 }
 719         }
 720         break;
 721 }
 722 g_free(dpoi.txt_label);
 723
 724 g_free(poi.label);
 725 g_free(poi.desc);
 726 g_free(p_latlon);
 727
 728 gtk_widget_hide_all(dialog);
 729
 730 return TRUE;
 731 }
 732
 733 static gboolean
 734 poi_quick_button_cb(GtkWidget *w, gpointer data)
 735 {
 736 gtk_widget_destroy(dialog_qp);
 737 return TRUE;
 738 }
 739
 740 gboolean
 741 poi_quick_dialog(guint unitx, guint unity)
 742 {
 743 GtkWidget *table;
 744 GtkWidget *buttons[POI_QUICK_BUTTONS];
 745 guint x,y;
 746 poi_info poi;
 747
 748 unit2latlon(unitx, unity, poi.lat, poi.lon);
 749
 750 dialog_qp = gtk_dialog_new_with_buttons(_("Quick POI"),
 751                 GTK_WINDOW(_window),
 752                     GTK_DIALOG_MODAL,
 753                         GTK_STOCK_CANCEL,
 754                         GTK_RESPONSE_REJECT,
 755                         NULL);
 756
 757 #ifdef WITH_OSSO_NOTYET
 758         /* Enable the help button. */
 759         ossohelp_dialog_help_enable(GTK_DIALOG(dialog_qp), HELP_ID_POIQUICK, _osso);
 760 #endif
 761
 762 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_qp)->vbox), table = gtk_table_new(3, 3, FALSE), TRUE, TRUE, 0);
 763
 764 gtk_table_set_col_spacings(GTK_TABLE(table), 6);
 765 gtk_table_set_row_spacings(GTK_TABLE(table), 6);
 766 gtk_table_set_homogeneous(GTK_TABLE(table), TRUE);
 767
 768 for (x=1;x<=3;x++) {
 769         for (y=1;y<=3;y++) {
 770                 gchar *btnlabel;
 771
 772                 buttons[x*y]=gtk_button_new_with_label(quick_poi_categories[x*y-1].name);
 773                 gtk_table_attach(GTK_TABLE(table), buttons[x*y], x-1, x, y-1, y, GTK_FILL, 0, 2, 4);
 774                 g_free(btnlabel);
 775                 g_signal_connect(G_OBJECT(buttons[x*y]), "clicked", G_CALLBACK(poi_quick_button_cb), GINT_TO_POINTER(quick_poi_categories[x*y-1].type));
 776         }
 777 }
 778
 779 gtk_widget_show_all(dialog_qp);
 780
 781 if (GTK_RESPONSE_REJECT == gtk_dialog_run(GTK_DIALOG(dialog_qp))) {
 782         gtk_widget_destroy(dialog_qp);
 783         return TRUE;
 784 }
 785
 786 return TRUE;
 787 }