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