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