trunk/src/relation_edit.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of OSM2Go.
 *
 * OSM2Go is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OSM2Go is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OSM2Go.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "appdata.h"

/* --------------- relation dialog for an item (node or way) ----------- */

typedef struct {
  relation_item_t *item;
  appdata_t *appdata;
  GtkWidget *dialog, *view;
  GtkListStore *store;
  GtkWidget *but_add, *but_edit, *but_remove;
} relitem_context_t;

enum {
  RELITEM_COL_SELECTED = 0,
  RELITEM_COL_TYPE,
  RELITEM_COL_ROLE,
  RELITEM_COL_NAME,
  RELITEM_COL_DATA,
  RELITEM_NUM_COLS
};

static void relation_list_selected(relitem_context_t *context, 
                                   gboolean selected) {

  if(context->but_remove)
    gtk_widget_set_sensitive(context->but_remove, FALSE);
  if(context->but_edit)
    gtk_widget_set_sensitive(context->but_edit, selected);
}

static gboolean
relation_list_selection_func(GtkTreeSelection *selection, GtkTreeModel *model,
                     GtkTreePath *path, gboolean path_currently_selected,
                     gpointer userdata) {
  relitem_context_t *context = (relitem_context_t*)userdata;
  GtkTreeIter iter;
    
  if(gtk_tree_model_get_iter(model, &iter, path)) {
    printf("selected an entry on the list\n");

    g_assert(gtk_tree_path_get_depth(path) == 1);
    relation_list_selected(context, TRUE);
  }
  
  return TRUE; /* allow selection state to change */
}

static void relation_remove_item(relation_t *relation, relation_item_t *item) {

  printf("remove item of type %d from relation #%ld\n", 
         item->type, relation->id);

  member_t **member = &relation->member;
  while(*member) {
    if(((*member)->type == item->type) &&
       (((item->type == NODE) && (item->node == (*member)->node)) ||
        ((item->type == WAY) && (item->way == (*member)->way)) ||
      ((item->type == RELATION) && (item->relation == (*member)->relation)))) {
      
      member_t *next = (*member)->next;
      osm_member_free(*member);
      *member = next;

      relation->flags |= OSM_FLAG_DIRTY;

      return;
    } else
      member = &(*member)->next;
  }
  g_assert(0);
}

typedef struct role_chain_s {
  char *role;
  struct role_chain_s *next;
} role_chain_t;

static void relation_add_item(GtkWidget *parent,
                              relation_t *relation, relation_item_t *item) {
  role_chain_t *chain = NULL, **chainP = &chain;

  printf("add item of type %d to relation #%ld\n", 
         item->type, relation->id);

  /* ask the user for the role of the new item in this relation */
  
  /* collect roles first */
  member_t *member = relation->member;
  while(member) {
    if(member->role) {
      /* check if this role has already been saved */
      gboolean already_stored = FALSE;
      role_chain_t *crole = chain;
      while(crole) {
        if(strcasecmp(crole->role, member->role) == 0) already_stored = TRUE;
        crole = crole->next;
      }
      
      /* not stored yet: attach it */
      if(!already_stored) {
        *chainP = g_new0(role_chain_t, 1);
        (*chainP)->role = g_strdup(member->role);
        chainP = &(*chainP)->next;
      }
    }
    member = member->next;
  }

  /* ------------------ role dialog ---------------- */
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("Select role"),
          GTK_WINDOW(parent), GTK_DIALOG_MODAL,
          GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, 
          GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
          NULL);

  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);

  char *type = osm_tag_get_by_key(relation->tag, "type");

  char *info_str = NULL;
  if(type) info_str = g_strdup_printf(_("In relation of type: %s"), type);
  else     info_str = g_strdup_printf(_("In relation #%ld"), relation->id);
  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), 
                              gtk_label_new(info_str));
  g_free(info_str);

  char *name = osm_tag_get_by_key(relation->tag, "name");
  if(name) 
    gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), 
                                gtk_label_new(name));

  GtkWidget *hbox = gtk_hbox_new(FALSE, 8);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_label_new(_("Role:")));

  GtkWidget *entry = NULL;
  if(chain) {
    entry = gtk_combo_box_entry_new_text();

    /* fill combo box with presets */
    while(chain) {
      role_chain_t *next = chain->next;
      gtk_combo_box_append_text(GTK_COMBO_BOX(entry), chain->role);
      g_free(chain);
      chain = next;
    }
  } else
    entry = gtk_entry_new();

  gtk_box_pack_start_defaults(GTK_BOX(hbox), entry);
  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox);

  gtk_widget_show_all(dialog);
  if(GTK_RESPONSE_ACCEPT != gtk_dialog_run(GTK_DIALOG(dialog))) {
    printf("user clicked cancel\n");
    gtk_widget_destroy(dialog);
    return;
  }
  
  printf("user clicked ok\n");

  /* get role from dialog */
  char *ptr = NULL;

  if(GTK_IS_COMBO_BOX(entry))
    ptr = gtk_combo_box_get_active_text(GTK_COMBO_BOX(entry));
  else
    ptr = (char*)gtk_entry_get_text(GTK_ENTRY(entry));

  char *role = NULL;
  if(ptr && strlen(ptr)) role = g_strdup(ptr);

  gtk_widget_destroy(dialog);

  /* search end of member chain */
  member_t **memberP = &relation->member;
  while(*memberP) memberP = &(*memberP)->next;

  /* create new member */
  *memberP = g_new0(member_t, 1);
  (*memberP)->type = item->type;
  (*memberP)->role = role;
  switch(item->type) {
  case NODE:
    (*memberP)->node = item->node;
    break;
  case WAY:
    (*memberP)->way = item->way;
    break;
  case RELATION:
    (*memberP)->relation = item->relation;
    break;
  default:
    g_assert((item->type == NODE)||(item->type == WAY)||
             (item->type == RELATION));
    break;
  }

  relation->flags |= OSM_FLAG_DIRTY;
}

static void on_relation_add(GtkWidget *but, relitem_context_t *context) {
  /* open a dialog where the user can pick from a list of all */
  /* relations */
}

static relation_t *get_selection(relitem_context_t *context) {
  GtkTreeSelection *selection;
  GtkTreeModel     *model;
  GtkTreeIter       iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->view));
  if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
    relation_t *relation;
    gtk_tree_model_get(model, &iter, RELITEM_COL_DATA, &relation, -1);
    return(relation);
  }
  return NULL;
}

static void on_relation_edit(GtkWidget *but, relitem_context_t *context) {
  relation_t *sel = get_selection(context);
  if(!sel) return;

  printf("edit relation #%ld\n", sel->id);

  info_dialog(context->dialog, context->appdata, sel);
}

static void on_relation_remove(GtkWidget *but, relitem_context_t *context) {
  relation_t *sel = get_selection(context);
  if(!sel) return;

  printf("remove relation #%ld\n", sel->id);
}

static void
relitem_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
              relitem_context_t *context) {
  GtkTreePath *path;
  GtkTreeIter iter;

  path = gtk_tree_path_new_from_string(path_str);
  gtk_tree_model_get_iter(GTK_TREE_MODEL(context->store), &iter, path);

  /* get current enabled flag */
  gboolean enabled;
  gtk_tree_model_get(GTK_TREE_MODEL(context->store), &iter, 
                     RELITEM_COL_SELECTED, &enabled, -1);

  /* change it and store it */
  enabled = !enabled;
  gtk_list_store_set(context->store, &iter, RELITEM_COL_SELECTED, enabled, -1);

  gtk_tree_path_free(path);
}

static gboolean relitem_is_in_relation(relation_item_t *item, relation_t *relation) {
  member_t *member = relation->member;
  while(member) {
    switch(member->type) {

    case NODE:
      if((item->type == NODE) && (item->node == member->node))
        return TRUE;
      break;

    case WAY:
      if((item->type == WAY) && (item->way == member->way))
        return TRUE;
      break;

    default:
      break;
    }
    member = member->next;
  }
  return FALSE;
}

static char *relitem_get_role_in_relation(relation_item_t *item, relation_t *relation) {
  member_t *member = relation->member;
  while(member) {
    switch(member->type) {

    case NODE:
      if((item->type == NODE) && (item->node == member->node))
        return member->role;
      break;

    case WAY:
      if((item->type == WAY) && (item->way == member->way))
        return member->role;
      break;

    default:
      break;
    }
    member = member->next;
  }
  return NULL;
}

static GtkWidget *relation_list(relitem_context_t *context) {
  GtkWidget *vbox = gtk_vbox_new(FALSE,3);
  context->view = gtk_tree_view_new();

  gtk_tree_selection_set_select_function(
         gtk_tree_view_get_selection(GTK_TREE_VIEW(context->view)), 
         relation_list_selection_func, 
         context, NULL);


  /* --- "selected" column --- */
  GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
  g_signal_connect(renderer, "toggled", G_CALLBACK(relitem_toggled), context);
  gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
        -1, _(""), renderer, 
        "active", RELITEM_COL_SELECTED, 
        NULL);

  /* --- "Type" column --- */
  renderer = gtk_cell_renderer_text_new();
  gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
        -1, _("Type"), renderer, "text", RELITEM_COL_TYPE, NULL);

  /* --- "Role" column --- */
  renderer = gtk_cell_renderer_text_new();
  gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
        -1, _("Role"), renderer, "text", RELITEM_COL_ROLE, NULL);

  /* --- "Name" column --- */
  renderer = gtk_cell_renderer_text_new();
  g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
  GtkTreeViewColumn *column = 
    gtk_tree_view_column_new_with_attributes(_("Name"), renderer, 
                 "text", RELITEM_COL_NAME, NULL);
  gtk_tree_view_column_set_expand(column, TRUE);
  gtk_tree_view_insert_column(GTK_TREE_VIEW(context->view), column, -1);


  /* build and fill the store */
  context->store = gtk_list_store_new(RELITEM_NUM_COLS, 
                G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, 
                G_TYPE_STRING, G_TYPE_POINTER);

  gtk_tree_view_set_model(GTK_TREE_VIEW(context->view), 
                          GTK_TREE_MODEL(context->store));

  GtkTreeIter iter;
  relation_t *relation = context->appdata->osm->relation;
  while(relation) {
    /* try to find something descriptive */
    char *name = osm_tag_get_by_key(relation->tag, "name");
    if(!name) name = osm_tag_get_by_key(relation->tag, "ref");

    /* Append a row and fill in some data */
    gtk_list_store_append(context->store, &iter);
    gtk_list_store_set(context->store, &iter,
       RELITEM_COL_SELECTED, relitem_is_in_relation(context->item, relation),
       RELITEM_COL_TYPE, osm_tag_get_by_key(relation->tag, "type"),
       RELITEM_COL_ROLE, relitem_get_role_in_relation(context->item, relation),
       RELITEM_COL_NAME, name,
       RELITEM_COL_DATA, relation,
       -1);
    
    relation = relation->next;
  }
  
  g_object_unref(context->store);

  /* put it into a scrolled window */
  GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 
                                 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), 
                                      GTK_SHADOW_ETCHED_IN);
  gtk_container_add(GTK_CONTAINER(scrolled_window), context->view);

  gtk_box_pack_start_defaults(GTK_BOX(vbox), scrolled_window);

  /* ------- button box ------------ */

  GtkWidget *hbox = gtk_hbox_new(TRUE,3);

  context->but_add = gtk_button_new_with_label(_("Add..."));
  gtk_widget_set_sensitive(context->but_add, FALSE);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_add);
  gtk_signal_connect(GTK_OBJECT(context->but_add), "clicked",
                     GTK_SIGNAL_FUNC(on_relation_add), context);

  context->but_edit = gtk_button_new_with_label(_("Edit..."));
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_edit);
  gtk_signal_connect(GTK_OBJECT(context->but_edit), "clicked",
                     GTK_SIGNAL_FUNC(on_relation_edit), context);

  context->but_remove = gtk_button_new_with_label(_("Remove"));
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_remove);
  gtk_signal_connect(GTK_OBJECT(context->but_remove), "clicked",
                     GTK_SIGNAL_FUNC(on_relation_remove), context);

  relation_list_selected(context, FALSE);

  gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
  return vbox;
}

void relation_add_dialog(appdata_t *appdata, relation_item_t *relitem) {
  relitem_context_t *context = g_new0(relitem_context_t, 1);
  map_t *map = appdata->map;
  g_assert(map);

  context->appdata = appdata;
  context->item = relitem;

  char *str = NULL;
  switch(relitem->type) {
  case NODE:
    str = g_strdup_printf(_("Relations for node #%ld"), relitem->node->id);
    break;
  case WAY:
    str = g_strdup_printf(_("Relations for way #%ld"), relitem->way->id);
    break;
  default:
    g_assert((relitem->type == NODE) || (relitem->type == WAY));
    break;
  }
  
  context->dialog = gtk_dialog_new_with_buttons(str,
        GTK_WINDOW(appdata->window), GTK_DIALOG_MODAL,
        GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, 
        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 
        NULL);
  g_free(str);
  
  gtk_dialog_set_default_response(GTK_DIALOG(context->dialog), 
                                  GTK_RESPONSE_ACCEPT);

  /* making the dialog a little wider makes it less "crowded" */
#ifdef USE_HILDON
  gtk_window_set_default_size(GTK_WINDOW(context->dialog), 500, 300);
#else
  gtk_window_set_default_size(GTK_WINDOW(context->dialog), 400, 200);
#endif
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(context->dialog)->vbox),
                     relation_list(context), TRUE, TRUE, 0);

  /* ----------------------------------- */

  gtk_widget_show_all(context->dialog);
  if(gtk_dialog_run(GTK_DIALOG(context->dialog)) == GTK_RESPONSE_ACCEPT) {
    printf("accepting new relation memberships\n");

    /* walk the entire store to get all values */
    GtkTreeIter iter;
    gboolean loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(context->store), &iter);
    while(loop) {
      gboolean enabled;
      relation_t *relation;

      gtk_tree_model_get(GTK_TREE_MODEL(context->store), &iter, 
                         RELITEM_COL_SELECTED, &enabled, 
                         RELITEM_COL_DATA, &relation, 
                         -1);


      if(relation && (enabled != relitem_is_in_relation(relitem, relation))) {
        printf("membership for relation #%ld has changed to %s\n", 
               relation->id, enabled?"yes":"no"); 

        if(!enabled) relation_remove_item(relation, relitem);
        else         relation_add_item(context->dialog, relation, relitem);
      }
      
      loop = gtk_tree_model_iter_next(GTK_TREE_MODEL(context->store), &iter);
    }
  }

  gtk_widget_destroy(context->dialog);

  g_free(context);
}
1	harbaum	1	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of OSM2Go.
5			*
6			* OSM2Go is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* OSM2Go is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with OSM2Go. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			#include "appdata.h"
21
22			/* --------------- relation dialog for an item (node or way) ----------- */
23
24			typedef struct {
25			relation_item_t *item;
26			appdata_t *appdata;
27			GtkWidget dialog, view;
28			GtkListStore *store;
29			GtkWidget but_add, but_edit, *but_remove;
30			} relitem_context_t;
31
32			enum {
33			RELITEM_COL_SELECTED = 0,
34			RELITEM_COL_TYPE,
35			RELITEM_COL_ROLE,
36			RELITEM_COL_NAME,
37			RELITEM_COL_DATA,
38			RELITEM_NUM_COLS
39			};
40
41			static void relation_list_selected(relitem_context_t *context,
42			gboolean selected) {
43	harbaum	42
44			if(context->but_remove)
45			gtk_widget_set_sensitive(context->but_remove, FALSE);
46			if(context->but_edit)
47			gtk_widget_set_sensitive(context->but_edit, selected);
48	harbaum	1	}
49
50			static gboolean
51			relation_list_selection_func(GtkTreeSelection selection, GtkTreeModel model,
52			GtkTreePath *path, gboolean path_currently_selected,
53			gpointer userdata) {
54			relitem_context_t context = (relitem_context_t)userdata;
55			GtkTreeIter iter;
56
57			if(gtk_tree_model_get_iter(model, &iter, path)) {
58	harbaum	72	printf("selected an entry on the list\n");
59
60	harbaum	1	g_assert(gtk_tree_path_get_depth(path) == 1);
61			relation_list_selected(context, TRUE);
62			}
63
64			return TRUE; /* allow selection state to change */
65			}
66
67			static void relation_remove_item(relation_t relation, relation_item_t item) {
68
69			printf("remove item of type %d from relation #%ld\n",
70			item->type, relation->id);
71
72			member_t **member = &relation->member;
73			while(*member) {
74			if(((*member)->type == item->type) &&
75			(((item->type == NODE) && (item->node == (*member)->node)) \|\|
76			((item->type == WAY) && (item->way == (*member)->way)) \|\|
77			((item->type == RELATION) && (item->relation == (*member)->relation)))) {
78
79			member_t next = (member)->next;
80			osm_member_free(*member);
81			*member = next;
82
83			relation->flags \|= OSM_FLAG_DIRTY;
84
85			return;
86			} else
87			member = &(*member)->next;
88			}
89			g_assert(0);
90			}
91
92			typedef struct role_chain_s {
93			char *role;
94			struct role_chain_s *next;
95			} role_chain_t;
96
97			static void relation_add_item(GtkWidget *parent,
98			relation_t relation, relation_item_t item) {
99			role_chain_t chain = NULL, *chainP = &chain;
100
101			printf("add item of type %d to relation #%ld\n",
102			item->type, relation->id);
103
104			/* ask the user for the role of the new item in this relation */
105
106			/* collect roles first */
107			member_t *member = relation->member;
108			while(member) {
109			if(member->role) {
110			/* check if this role has already been saved */
111			gboolean already_stored = FALSE;
112			role_chain_t *crole = chain;
113			while(crole) {
114			if(strcasecmp(crole->role, member->role) == 0) already_stored = TRUE;
115			crole = crole->next;
116			}
117
118			/* not stored yet: attach it */
119			if(!already_stored) {
120			*chainP = g_new0(role_chain_t, 1);
121			(*chainP)->role = g_strdup(member->role);
122			chainP = &(*chainP)->next;
123			}
124			}
125			member = member->next;
126			}
127
128			/* ------------------ role dialog ---------------- */
129			GtkWidget *dialog = gtk_dialog_new_with_buttons(_("Select role"),
130			GTK_WINDOW(parent), GTK_DIALOG_MODAL,
131			GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
132			GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
133			NULL);
134
135			gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
136
137			char *type = osm_tag_get_by_key(relation->tag, "type");
138
139			char *info_str = NULL;
140			if(type) info_str = g_strdup_printf(_("In relation of type: %s"), type);
141			else info_str = g_strdup_printf(_("In relation #%ld"), relation->id);
142			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox),
143			gtk_label_new(info_str));
144			g_free(info_str);
145
146			char *name = osm_tag_get_by_key(relation->tag, "name");
147			if(name)
148			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox),
149			gtk_label_new(name));
150
151			GtkWidget *hbox = gtk_hbox_new(FALSE, 8);
152			gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_label_new(_("Role:")));
153
154			GtkWidget *entry = NULL;
155			if(chain) {
156			entry = gtk_combo_box_entry_new_text();
157
158			/* fill combo box with presets */
159			while(chain) {
160			role_chain_t *next = chain->next;
161			gtk_combo_box_append_text(GTK_COMBO_BOX(entry), chain->role);
162			g_free(chain);
163			chain = next;
164			}
165			} else
166			entry = gtk_entry_new();
167
168			gtk_box_pack_start_defaults(GTK_BOX(hbox), entry);
169			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox);
170
171			gtk_widget_show_all(dialog);
172			if(GTK_RESPONSE_ACCEPT != gtk_dialog_run(GTK_DIALOG(dialog))) {
173			printf("user clicked cancel\n");
174			gtk_widget_destroy(dialog);
175			return;
176			}
177
178			printf("user clicked ok\n");
179
180			/* get role from dialog */
181			char *ptr = NULL;
182
183			if(GTK_IS_COMBO_BOX(entry))
184			ptr = gtk_combo_box_get_active_text(GTK_COMBO_BOX(entry));
185			else
186			ptr = (char*)gtk_entry_get_text(GTK_ENTRY(entry));
187
188			char *role = NULL;
189			if(ptr && strlen(ptr)) role = g_strdup(ptr);
190
191			gtk_widget_destroy(dialog);
192
193			/* search end of member chain */
194			member_t **memberP = &relation->member;
195			while(memberP) memberP = &(memberP)->next;
196
197			/* create new member */
198			*memberP = g_new0(member_t, 1);
199			(*memberP)->type = item->type;
200			(*memberP)->role = role;
201			switch(item->type) {
202			case NODE:
203			(*memberP)->node = item->node;
204			break;
205			case WAY:
206			(*memberP)->way = item->way;
207			break;
208			case RELATION:
209			(*memberP)->relation = item->relation;
210			break;
211			default:
212			g_assert((item->type == NODE)\|\|(item->type == WAY)\|\|
213			(item->type == RELATION));
214			break;
215			}
216
217			relation->flags \|= OSM_FLAG_DIRTY;
218			}
219
220			static void on_relation_add(GtkWidget but, relitem_context_t context) {
221			/* open a dialog where the user can pick from a list of all */
222			/* relations */
223			}
224
225			static relation_t get_selection(relitem_context_t context) {
226			GtkTreeSelection *selection;
227			GtkTreeModel *model;
228			GtkTreeIter iter;
229
230			selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(context->view));
231			if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
232			relation_t *relation;
233			gtk_tree_model_get(model, &iter, RELITEM_COL_DATA, &relation, -1);
234			return(relation);
235			}
236			return NULL;
237			}
238
239			static void on_relation_edit(GtkWidget but, relitem_context_t context) {
240			relation_t *sel = get_selection(context);
241			if(!sel) return;
242
243			printf("edit relation #%ld\n", sel->id);
244
245			info_dialog(context->dialog, context->appdata, sel);
246			}
247
248			static void on_relation_remove(GtkWidget but, relitem_context_t context) {
249			relation_t *sel = get_selection(context);
250			if(!sel) return;
251
252			printf("remove relation #%ld\n", sel->id);
253			}
254
255			static void
256			relitem_toggled(GtkCellRendererToggle cell, const gchar path_str,
257			relitem_context_t *context) {
258			GtkTreePath *path;
259			GtkTreeIter iter;
260
261			path = gtk_tree_path_new_from_string(path_str);
262			gtk_tree_model_get_iter(GTK_TREE_MODEL(context->store), &iter, path);
263
264			/* get current enabled flag */
265			gboolean enabled;
266			gtk_tree_model_get(GTK_TREE_MODEL(context->store), &iter,
267			RELITEM_COL_SELECTED, &enabled, -1);
268
269			/* change it and store it */
270			enabled = !enabled;
271			gtk_list_store_set(context->store, &iter, RELITEM_COL_SELECTED, enabled, -1);
272
273			gtk_tree_path_free(path);
274			}
275
276			static gboolean relitem_is_in_relation(relation_item_t item, relation_t relation) {
277			member_t *member = relation->member;
278			while(member) {
279			switch(member->type) {
280
281			case NODE:
282			if((item->type == NODE) && (item->node == member->node))
283			return TRUE;
284			break;
285
286			case WAY:
287			if((item->type == WAY) && (item->way == member->way))
288			return TRUE;
289			break;
290
291			default:
292			break;
293			}
294			member = member->next;
295			}
296			return FALSE;
297			}
298
299			static char relitem_get_role_in_relation(relation_item_t item, relation_t *relation) {
300			member_t *member = relation->member;
301			while(member) {
302			switch(member->type) {
303
304			case NODE:
305			if((item->type == NODE) && (item->node == member->node))
306			return member->role;
307			break;
308
309			case WAY:
310			if((item->type == WAY) && (item->way == member->way))
311			return member->role;
312			break;
313
314			default:
315			break;
316			}
317			member = member->next;
318			}
319			return NULL;
320			}
321
322			static GtkWidget relation_list(relitem_context_t context) {
323			GtkWidget *vbox = gtk_vbox_new(FALSE,3);
324			context->view = gtk_tree_view_new();
325
326			gtk_tree_selection_set_select_function(
327			gtk_tree_view_get_selection(GTK_TREE_VIEW(context->view)),
328			relation_list_selection_func,
329			context, NULL);
330
331
332			/* --- "selected" column --- */
333			GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
334			g_signal_connect(renderer, "toggled", G_CALLBACK(relitem_toggled), context);
335			gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
336			-1, _(""), renderer,
337			"active", RELITEM_COL_SELECTED,
338			NULL);
339
340			/* --- "Type" column --- */
341			renderer = gtk_cell_renderer_text_new();
342			gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
343			-1, _("Type"), renderer, "text", RELITEM_COL_TYPE, NULL);
344
345			/* --- "Role" column --- */
346			renderer = gtk_cell_renderer_text_new();
347			gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(context->view),
348			-1, _("Role"), renderer, "text", RELITEM_COL_ROLE, NULL);
349
350			/* --- "Name" column --- */
351			renderer = gtk_cell_renderer_text_new();
352			g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
353			GtkTreeViewColumn *column =
354			gtk_tree_view_column_new_with_attributes(_("Name"), renderer,
355			"text", RELITEM_COL_NAME, NULL);
356			gtk_tree_view_column_set_expand(column, TRUE);
357			gtk_tree_view_insert_column(GTK_TREE_VIEW(context->view), column, -1);
358
359
360			/* build and fill the store */
361			context->store = gtk_list_store_new(RELITEM_NUM_COLS,
362			G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING,
363			G_TYPE_STRING, G_TYPE_POINTER);
364
365			gtk_tree_view_set_model(GTK_TREE_VIEW(context->view),
366			GTK_TREE_MODEL(context->store));
367
368			GtkTreeIter iter;
369			relation_t *relation = context->appdata->osm->relation;
370			while(relation) {
371			/* try to find something descriptive */
372			char *name = osm_tag_get_by_key(relation->tag, "name");
373			if(!name) name = osm_tag_get_by_key(relation->tag, "ref");
374
375			/* Append a row and fill in some data */
376			gtk_list_store_append(context->store, &iter);
377			gtk_list_store_set(context->store, &iter,
378			RELITEM_COL_SELECTED, relitem_is_in_relation(context->item, relation),
379			RELITEM_COL_TYPE, osm_tag_get_by_key(relation->tag, "type"),
380			RELITEM_COL_ROLE, relitem_get_role_in_relation(context->item, relation),
381			RELITEM_COL_NAME, name,
382			RELITEM_COL_DATA, relation,
383			-1);
384
385			relation = relation->next;
386			}
387
388			g_object_unref(context->store);
389
390			/* put it into a scrolled window */
391			GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
392			gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
393			GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
394			gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window),
395			GTK_SHADOW_ETCHED_IN);
396			gtk_container_add(GTK_CONTAINER(scrolled_window), context->view);
397
398			gtk_box_pack_start_defaults(GTK_BOX(vbox), scrolled_window);
399
400			/* ------- button box ------------ */
401
402			GtkWidget *hbox = gtk_hbox_new(TRUE,3);
403
404			context->but_add = gtk_button_new_with_label(_("Add..."));
405			gtk_widget_set_sensitive(context->but_add, FALSE);
406			gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_add);
407			gtk_signal_connect(GTK_OBJECT(context->but_add), "clicked",
408			GTK_SIGNAL_FUNC(on_relation_add), context);
409
410			context->but_edit = gtk_button_new_with_label(_("Edit..."));
411			gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_edit);
412			gtk_signal_connect(GTK_OBJECT(context->but_edit), "clicked",
413			GTK_SIGNAL_FUNC(on_relation_edit), context);
414
415			context->but_remove = gtk_button_new_with_label(_("Remove"));
416			gtk_box_pack_start_defaults(GTK_BOX(hbox), context->but_remove);
417			gtk_signal_connect(GTK_OBJECT(context->but_remove), "clicked",
418			GTK_SIGNAL_FUNC(on_relation_remove), context);
419
420			relation_list_selected(context, FALSE);
421
422			gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
423			return vbox;
424			}
425
426			void relation_add_dialog(appdata_t appdata, relation_item_t relitem) {
427			relitem_context_t *context = g_new0(relitem_context_t, 1);
428			map_t *map = appdata->map;
429			g_assert(map);
430
431			context->appdata = appdata;
432			context->item = relitem;
433
434			char *str = NULL;
435			switch(relitem->type) {
436			case NODE:
437			str = g_strdup_printf(_("Relations for node #%ld"), relitem->node->id);
438			break;
439			case WAY:
440			str = g_strdup_printf(_("Relations for way #%ld"), relitem->way->id);
441			break;
442			default:
443			g_assert((relitem->type == NODE) \|\| (relitem->type == WAY));
444			break;
445			}
446
447			context->dialog = gtk_dialog_new_with_buttons(str,
448			GTK_WINDOW(appdata->window), GTK_DIALOG_MODAL,
449			GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
450			GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
451			NULL);
452			g_free(str);
453
454			gtk_dialog_set_default_response(GTK_DIALOG(context->dialog),
455			GTK_RESPONSE_ACCEPT);
456
457			/* making the dialog a little wider makes it less "crowded" */
458			#ifdef USE_HILDON
459			gtk_window_set_default_size(GTK_WINDOW(context->dialog), 500, 300);
460			#else
461			gtk_window_set_default_size(GTK_WINDOW(context->dialog), 400, 200);
462			#endif
463			gtk_box_pack_start(GTK_BOX(GTK_DIALOG(context->dialog)->vbox),
464			relation_list(context), TRUE, TRUE, 0);
465
466			/* ----------------------------------- */
467
468			gtk_widget_show_all(context->dialog);
469			if(gtk_dialog_run(GTK_DIALOG(context->dialog)) == GTK_RESPONSE_ACCEPT) {
470			printf("accepting new relation memberships\n");
471
472			/* walk the entire store to get all values */
473			GtkTreeIter iter;
474			gboolean loop = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(context->store), &iter);
475			while(loop) {
476			gboolean enabled;
477			relation_t *relation;
478
479			gtk_tree_model_get(GTK_TREE_MODEL(context->store), &iter,
480			RELITEM_COL_SELECTED, &enabled,
481			RELITEM_COL_DATA, &relation,
482			-1);
483
484
485			if(relation && (enabled != relitem_is_in_relation(relitem, relation))) {
486			printf("membership for relation #%ld has changed to %s\n",
487			relation->id, enabled?"yes":"no");
488
489			if(!enabled) relation_remove_item(relation, relitem);
490			else relation_add_item(context->dialog, relation, relitem);
491			}
492
493			loop = gtk_tree_model_iter_next(GTK_TREE_MODEL(context->store), &iter);
494			}
495			}
496
497			gtk_widget_destroy(context->dialog);
498
499			g_free(context);
500			}