aboutsummaryrefslogtreecommitdiff
path: root/src/identity
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2013-09-07 19:14:20 +0000
committerChristian Grothoff <christian@grothoff.org>2013-09-07 19:14:20 +0000
commit7459ebc4df78f2d5c7b69451434d9c4ec90a16b9 (patch)
treeaf672fd89ed31a53e8c2e116b8edc9734e587e74 /src/identity
parent06563b7a66e1045a963933eec87d4328b6b6efb3 (diff)
downloadgnunet-gtk-7459ebc4df78f2d5c7b69451434d9c4ec90a16b9.tar.gz
gnunet-gtk-7459ebc4df78f2d5c7b69451434d9c4ec90a16b9.zip
-completing widget handling in advertise dialog
Diffstat (limited to 'src/identity')
-rw-r--r--src/identity/gnunet-identity-gtk_advertise.c1312
1 files changed, 252 insertions, 1060 deletions
diff --git a/src/identity/gnunet-identity-gtk_advertise.c b/src/identity/gnunet-identity-gtk_advertise.c
index e7974ce1..07ab09fd 100644
--- a/src/identity/gnunet-identity-gtk_advertise.c
+++ b/src/identity/gnunet-identity-gtk_advertise.c
@@ -26,10 +26,15 @@
26#include "gnunet-identity-gtk_advertise.h" 26#include "gnunet-identity-gtk_advertise.h"
27#include <gnunet/gnunet_fs_service.h> 27#include <gnunet/gnunet_fs_service.h>
28 28
29
30#define NEW_KEYWORD_TEXT "<add>"
31
32
29/** 33/**
30 * Types of metadata we offer for namespaces. 34 * Types of metadata we offer for namespaces.
31 */ 35 */
32static gint types[] = { 36static gint types[] =
37{
33 EXTRACTOR_METATYPE_TITLE, 38 EXTRACTOR_METATYPE_TITLE,
34 EXTRACTOR_METATYPE_KEYWORDS, 39 EXTRACTOR_METATYPE_KEYWORDS,
35 EXTRACTOR_METATYPE_SUBJECT, 40 EXTRACTOR_METATYPE_SUBJECT,
@@ -47,56 +52,57 @@ static gint types[] = {
47 * Columns in the metadata list store. 52 * Columns in the metadata list store.
48 */ 53 */
49enum METADATA_ModelColumns 54enum METADATA_ModelColumns
50 { 55{
51 /**
52 * A guint
53 */
54 METADATA_MC_TYPE_AS_ENUM = 0,
55
56 /**
57 * A gchararray
58 */
59 METADATA_MC_TYPE_AS_STRING = 1,
60 56
61 /** 57 /**
62 * A gchararray 58 * A guint
63 */ 59 */
64 METADATA_MC_VALUE = 2 60 METADATA_MC_TYPE_AS_ENUM = 0,
61
62 /**
63 * A gchararray
64 */
65 METADATA_MC_TYPE_AS_STRING = 1,
65 66
66 }; 67 /**
68 * A gchararray
69 */
70 METADATA_MC_VALUE = 2
71
72};
67 73
68 74
69/** 75/**
70 * Columns in the keyword list tree store. 76 * Columns in the keyword list tree store.
71 */ 77 */
72enum KEYWORDS_ModelColumns 78enum KEYWORDS_ModelColumns
73 { 79{
74 80
75 /** 81 /**
76 * A gchararray 82 * A gchararray
77 */ 83 */
78 KEYWORDS_MC_KEYWORD = 0 84 KEYWORDS_MC_KEYWORD = 0
79 85
80 }; 86};
81 87
82 88
83/** 89/**
84 * Columns in the meta types list tree store. 90 * Columns in the meta types list tree store.
85 */ 91 */
86enum METATYPES_ModelColumns 92enum METATYPES_ModelColumns
87 { 93{
88
89 /**
90 * A gchararray
91 */
92 METATYPES_MC_TYPE_AS_STRING = 0,
93
94 /**
95 * A guint
96 */
97 METATYPES_MC_TYPE_AS_ENUM = 1
98 94
99 }; 95 /**
96 * A gchararray
97 */
98 METATYPES_MC_TYPE_AS_STRING = 0,
99
100 /**
101 * A guint
102 */
103 METATYPES_MC_TYPE_AS_ENUM = 1
104
105};
100 106
101 107
102/** 108/**
@@ -134,9 +140,15 @@ struct AdvertiseContext
134 */ 140 */
135 GtkListStore *meta_types; 141 GtkListStore *meta_types;
136 142
143 /**
144 * Number of keywords in the view.
145 */
146 unsigned int num_keywords;
147
137}; 148};
138 149
139 150
151
140/** 152/**
141 * The user terminated the dialog. Perform the appropriate action. 153 * The user terminated the dialog. Perform the appropriate action.
142 * 154 *
@@ -161,1115 +173,295 @@ GNUNET_GTK_identity_advertise_dialog_response_cb (GtkDialog *dialog,
161 GNUNET_free (ac); 173 GNUNET_free (ac);
162} 174}
163 175
164
165/**
166 * FIXME: do we need this event? If so, what do we do?
167 */
168void
169GNUNET_GTK_identity_advertise_keywords_column_clicked_cb ()
170{
171 GNUNET_break (0);
172}
173
174 176
175/** 177/**
176 * User edited keywords in the keyword tree view. Update 178 * User edited keywords in the keyword tree view. Update
177 * the model accordingly. 179 * the model accordingly.
178 */
179void
180GNUNET_GTK_identity_advertise_keywords_text_edited_cb ()
181{
182 GNUNET_break (0);
183}
184
185
186/**
187 * User pushed a key in the metadata tree view. Check if it was
188 * "DEL" and if so, remove the selected values.
189 */
190void
191GNUNET_GTK_identity_advertise_metadata_treeview_key_press_event_cb ()
192{
193 GNUNET_break (0);
194}
195
196
197/**
198 * FIXME: how is this event triggered exactly?
199 */
200void
201GNUNET_GTK_identity_advertise_metadata_treeview_delete_event_cb ()
202{
203 GNUNET_break (0);
204}
205
206
207/**
208 * User edited metadata value. Update sensitivity of the 'add' button.
209 */
210void
211GNUNET_GTK_identity_advertise_metadata_value_text_edited_cb ()
212{
213 GNUNET_break (0);
214}
215
216
217/**
218 * User edited metadata type. Not sure we need to do something here...
219 */
220void
221GNUNET_GTK_identity_advertise_metadata_type_text_edited_cb ()
222{
223 GNUNET_break (0);
224}
225
226
227/**
228 * User clicked the 'add' button, get the type and value and update
229 * the metadata model.
230 */
231void
232GNUNET_GTK_identity_advertise_metadata_add_button_clicked_cb ()
233{
234 GNUNET_break (0);
235}
236
237
238/**
239 * Run the dialog for advertising a namespace.
240 * 180 *
241 * @param priv private key of the namespace to advertise 181 * @param renderer the object that created the signal
242 */ 182 * @param path the path identifying the edited cell
183 * @param new_text the new text
184 * @param user_data the 'struct AdvertiseContext'
185 */
243void 186void
244GIG_advertise_dialog_start_ (const struct GNUNET_CRYPTO_EccPrivateKey *priv) 187GNUNET_GTK_identity_advertise_keywords_text_edited_cb (GtkCellRendererText *renderer,
188 gchar *path,
189 gchar *new_text,
190 gpointer user_data)
245{ 191{
246 struct AdvertiseContext *ac; 192 struct AdvertiseContext *ac = user_data;
247 gint i; 193 GtkTreePath *tree_path;
248 GtkTreeIter iter; 194 GtkTreeIter iter;
195 char *old_text;
249 196
250 ac = GNUNET_new (struct AdvertiseContext); 197 tree_path = gtk_tree_path_new_from_string (path);
251 ac->priv = *priv; 198 if (NULL == tree_path)
252 ac->builder =
253 GNUNET_GTK_get_new_builder ("gnunet_identity_gtk_advertise_dialog.glade",
254 ac);
255 if (NULL == ac->builder)
256 { 199 {
257 GNUNET_break (0); 200 GNUNET_break (0);
258 GNUNET_free (ac);
259 return; 201 return;
260 } 202 }
261 ac->dialog = GTK_WIDGET (gtk_builder_get_object 203 if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (ac->keywords),
262 (ac->builder, "GNUNET_GTK_identity_advertise_dialog")); 204 &iter, tree_path))
263 ac->keywords = GTK_LIST_STORE (gtk_builder_get_object
264 (ac->builder, "GNUNET_GTK_identity_advertise_keywords_liststore"));
265 ac->metadata = GTK_LIST_STORE (gtk_builder_get_object
266 (ac->builder, "GNUNET_GTK_identity_advertise_metadata_liststore"));
267 ac->meta_types = GTK_LIST_STORE (gtk_builder_get_object
268 (ac->builder, "GNUNET_GTK_identity_metadata_types_liststore"));
269 for (i = 0; EXTRACTOR_METATYPE_RESERVED != types[i]; i++)
270 gtk_list_store_insert_with_values (ac->meta_types,
271 &iter, G_MAXINT,
272 METATYPES_MC_TYPE_AS_STRING,
273 EXTRACTOR_metatype_to_string (types[i]),
274 METATYPES_MC_TYPE_AS_ENUM,
275 types[i],
276 -1);
277 gtk_window_present (GTK_WINDOW (ac->dialog));
278}
279
280
281#if 0
282
283static void
284sort_order_list (struct GNUNET_GTK_NamespaceManagerContext *ctx,
285 int sort_column)
286{
287 int sorted = GNUNET_NO;
288 GtkTreeIter iter;
289 gint i;
290 gint row_count;
291 gint *row_indices, *row_ints;
292 gchar **row_strings;
293
294 ctx->sort_direction = ctx->sort_direction <= 0 ? 1 : 0;
295
296 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
297 ctx->ns_order_store), NULL);
298 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
299 ctx->ns_order_store), &iter))
300 return;
301
302 row_indices = g_new0 (gint, row_count);
303 row_ints = g_new0 (gint, row_count);
304 row_strings = g_new0 (gchar *, row_count);
305
306 for (i = 0; i < row_count; i++)
307 { 205 {
308 int an_int; 206 GNUNET_break (0);
309 char *a_string; 207 gtk_tree_path_free (tree_path);
310 row_indices[i] = i;
311 switch (sort_column)
312 {
313 case GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN:
314 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
315 sort_column, &an_int, -1);
316 row_ints[i] = an_int;
317 row_strings[i] = NULL;
318 break;
319 case GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN:
320 case GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN:
321 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
322 sort_column, &a_string, -1);
323 row_strings[i] = a_string;
324 break;
325 default:
326 row_strings[i] = NULL;
327 break;
328 }
329 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
330 ctx->ns_order_store), &iter))
331 break;
332 }
333
334 while (sorted != GNUNET_YES)
335 {
336 sorted = GNUNET_YES;
337 for (i = 0; i < row_count - 1; i++)
338 {
339 int cmp_result;
340
341 switch (sort_column)
342 {
343 case GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN:
344 cmp_result = row_ints[i] <= row_ints[i + 1] ? 0 : 1;
345 break;
346 case GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN:
347 case GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN:
348 /* FIXME: name can be UTF-8-encoded, use UTF-8-aware comparison func */
349 cmp_result = strcmp (row_strings[i], row_strings[i + 1]);
350 break;
351 default:
352 GNUNET_break (0);
353 cmp_result = 0;
354 break;
355 }
356
357 if (((ctx->sort_direction <= 0) && (cmp_result <= 0)) ||
358 ((ctx->sort_direction > 0) && (cmp_result > 0)))
359 {
360 int tmp_int, tmp_index;
361 char *tmp_string;
362 tmp_index = row_indices[i];
363 tmp_int = row_ints[i];
364 tmp_string = row_strings[i];
365 row_indices[i] = row_indices[i + 1];
366 row_ints[i] = row_ints[i + 1];
367 row_strings[i] = row_strings[i + 1];
368 row_ints[i + 1] = tmp_int;
369 row_strings[i + 1] = tmp_string;
370 row_indices[i + 1] = tmp_index;
371 sorted = GNUNET_NO;
372 }
373 }
374 }
375
376 gtk_list_store_reorder (ctx->ns_order_store, row_indices);
377
378 g_free (row_indices);
379 for (i = 0; i < row_count; i++)
380 g_free (row_strings[i]);
381 g_free (row_strings);
382 g_free (row_ints);
383}
384
385
386void
387GNUNET_GTK_namespace_manager_namespace_order_column_clicked_cb (
388 GtkTreeViewColumn *treeviewcolumn, gpointer user_data)
389{
390 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
391 if (treeviewcolumn == ctx->order_rank)
392 {
393 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN);
394 }
395 else if (treeviewcolumn == ctx->order_name)
396 {
397 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN);
398 }
399 else if (treeviewcolumn == ctx->order_id)
400 {
401 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN);
402 }
403}
404
405
406void
407GNUNET_GTK_namespace_manager_known_namespaces_delete_button_clicked_cb (
408 GtkButton *button, gpointer user_data)
409{
410 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
411 GtkTreeIter iter;
412 struct GNUNET_FS_PseudonymIdentifier *nsid;
413 GtkTreeRowReference *order_row, *known_row;
414 struct GNUNET_CONTAINER_MetaData *md;
415
416 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &iter))
417 return; 208 return;
418 209 }
419 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter, 210 gtk_tree_path_free (tree_path);
420 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid, 211 gtk_tree_model_get (GTK_TREE_MODEL (ac->keywords), &iter,
421 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row, 212 KEYWORDS_MC_KEYWORD, &old_text,
422 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md, 213 -1);
423 -1); 214 if (0 == strcmp (NEW_KEYWORD_TEXT, old_text))
424 /* Make sure the store does not contain references to freed objects */
425 gtk_list_store_set (ctx->known_ns_store, &iter,
426 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, NULL,
427 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
428 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, NULL,
429 -1);
430 GNUNET_CONTAINER_meta_data_destroy (md);
431 if (order_row != NULL)
432 { 215 {
433 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &iter)) 216 if ( (NULL != new_text) &&
217 (0 != strlen (new_text)) )
434 { 218 {
435 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter, 219 gtk_list_store_insert_with_values (ac->keywords, &iter, -1,
436 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1); 220 KEYWORDS_MC_KEYWORD, new_text,
437 gtk_list_store_set (ctx->ns_order_store, &iter, 221 -1);
438 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, NULL, -1); 222 ac->num_keywords++;
439 if (known_row != NULL)
440 gtk_tree_row_reference_free (known_row);
441 gtk_list_store_remove (ctx->ns_order_store, &iter);
442 } 223 }
443 gtk_tree_row_reference_free (order_row);
444 } 224 }
445 ctx->deleted_namespaces = g_list_prepend (ctx->deleted_namespaces, nsid);
446 gtk_list_store_remove (ctx->known_ns_store, &iter);
447
448 gtk_list_store_clear (ctx->ns_details_store);
449 GNUNET_CONTAINER_meta_data_destroy (ctx->uneditable_md);
450 ctx->uneditable_md = NULL;
451}
452
453
454void
455GNUNET_GTK_namespace_manager_known_namespaces_swap_rank_button_clicked_cb (
456 GtkButton *button, gpointer user_data)
457{
458 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
459 GtkTreeIter known_iter, order_iter;
460 struct GNUNET_CRYPTO_EccPublicKey *nsid;
461 int32_t old_rank, new_rank;
462 GtkTreeRowReference *order_row, *known_row;
463
464 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &known_iter))
465 return;
466
467 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
468 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
469 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, &old_rank,
470 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
471 -1);
472
473 if (old_rank == 0)
474 new_rank = -1;
475 else 225 else
476 new_rank = -old_rank;
477
478 gtk_list_store_set (ctx->known_ns_store, &known_iter,
479 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, new_rank,
480 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
481 -1);
482
483 if (order_row != NULL)
484 { 226 {
485 if (new_rank < 0) 227 if ( (NULL != new_text) &&
228 (0 != strlen (new_text)) )
486 { 229 {
487 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter)) 230 gtk_list_store_set (ac->keywords, &iter,
488 { 231 KEYWORDS_MC_KEYWORD, new_text,
489 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &order_iter, 232 -1);
490 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1);
491 gtk_list_store_remove (ctx->ns_order_store, &order_iter);
492 if (known_row != NULL)
493 gtk_tree_row_reference_free (known_row);
494 }
495 } 233 }
496 gtk_tree_row_reference_free (order_row); 234 else
497 }
498 if (new_rank >= 0)
499 {
500 char *name, *identifier;
501 if (order_row != NULL)
502 { 235 {
503 /* This should not happen */ 236 gtk_list_store_remove (ac->keywords, &iter);
504 GNUNET_break (0); 237 ac->num_keywords--;
505 } 238 }
506 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
507 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, &name,
508 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_COLUMN, &identifier,
509 -1);
510 known_row = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (
511 ctx->known_ns_store), &known_iter);
512 gtk_list_store_insert_with_values (ctx->ns_order_store, &order_iter, G_MAXINT,
513 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, new_rank,
514 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, name,
515 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN, identifier,
516 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_BIN_COLUMN, nsid,
517 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, known_row,
518 -1);
519 g_free (name);
520 g_free (identifier);
521 order_row = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (ctx->ns_order_store),
522 &order_iter);
523 gtk_list_store_set (ctx->known_ns_store, &known_iter,
524 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, order_row, -1);
525 } 239 }
240 g_free (old_text);
241 gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object
242 (ac->builder,
243 "GNUNET_GTK_identity_advertise_ok_button")),
244 0 != ac->num_keywords);
526} 245}
527 246
528 247
529void 248/**
530GNUNET_GTK_namespace_manager_namespace_order_apply_clicked_cb ( 249 * User pushed a key in the metadata tree view. Check if it was
531 GtkButton *button, gpointer user_data) 250 * "DEL" and if so, remove the selected values.
251 *
252 * @param widget widget creating the signal
253 * @param event the event to process
254 * @param user_data the 'struct AdvertiseContext'
255 * @return TRUE if we handled the event, FALSE if not
256 */
257gboolean
258GNUNET_GTK_identity_advertise_metadata_treeview_key_press_event_cb (GtkWidget *widget,
259 GdkEventKey *event,
260 gpointer user_data)
532{ 261{
533 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data; 262 struct AdvertiseContext *ac = user_data;
263 GtkTreeSelection *sel;
264 GtkTreeModel *model;
534 GtkTreeIter iter; 265 GtkTreeIter iter;
535 gint i;
536 gint row_count;
537 GtkTreeRowReference *known_row;
538 266
539 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL ( 267 if (event->keyval != GDK_KEY_Delete)
540 ctx->ns_order_store), NULL); 268 return FALSE;
541 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL ( 269 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW
542 ctx->ns_order_store), &iter)) 270 (gtk_builder_get_object
543 return; 271 (ac->builder,
544 272 "GNUNET_GTK_identity_advertise_metadata_treeview")));
545 for (i = 0; i < row_count; i++) 273 if (! gtk_tree_selection_get_selected (sel,
546 { 274 &model,
547 gtk_list_store_set (ctx->ns_order_store, &iter, 275 &iter))
548 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, i, -1);
549 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
550 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1);
551 if (known_row == NULL)
552 {
553 /* This is not supposed to happen. What to do? */
554 GNUNET_break (0);
555 }
556 else
557 { 276 {
558 GtkTreeIter known_iter; 277 gdk_beep ();
559 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (known_row, &known_iter)) 278 return TRUE;
560 {
561 gtk_list_store_set (ctx->known_ns_store, &known_iter,
562 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, i,
563 -1);
564 }
565 } 279 }
566 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL ( 280 gtk_list_store_remove (ac->metadata,
567 ctx->ns_order_store), &iter)) 281 &iter);
568 break; 282 return TRUE;
569 }
570}
571
572
573void
574GNUNET_GTK_namespace_manager_namespace_details_add_button_clicked_cb (
575 GtkButton *button, gpointer user_data)
576{
577 /* FIXME: add a row to the details list. Disabled at the moment, since
578 * metadata type selection is not implemented.
579 */
580} 283}
581 284
582 285
286/**
287 * User edited metadata value in the tree view. Update the model.
288 *
289 * @param renderer the object that created the signal
290 * @param path the path identifying the edited cell
291 * @param new_text the new text, if empty, remove the line
292 * @param user_data the 'struct AdvertiseContext'
293 */
583void 294void
584GNUNET_GTK_namespace_manager_namespace_details_delete_button_clicked_cb ( 295GNUNET_GTK_identity_advertise_metadata_value_text_edited_cb (GtkCellRendererText *renderer,
585 GtkButton *button, gpointer user_data) 296 gchar *path,
297 gchar *new_text,
298 gpointer user_data)
586{ 299{
587 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data; 300 struct AdvertiseContext *ac = user_data;
301 GtkTreePath *tree_path;
588 GtkTreeIter iter; 302 GtkTreeIter iter;
589 303
590 if (FALSE == gtk_tree_selection_get_selected (ctx->ns_details_sel, NULL, &iter)) 304 tree_path = gtk_tree_path_new_from_string (path);
591 return; 305 if (NULL == tree_path)
592
593 gtk_list_store_remove (ctx->ns_details_store, &iter);
594 gtk_widget_set_sensitive (ctx->details_apply_button, TRUE);
595}
596
597
598void
599GNUNET_GTK_namespace_manager_namespace_details_apply_button_clicked_cb (
600 GtkButton *button, gpointer user_data)
601{
602 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
603 GtkTreeIter iter, known_iter;
604 gint i;
605 gint row_count;
606 struct GNUNET_CONTAINER_MetaData *md, *old_md;
607 char *plugin_name;
608 int type;
609 char *type_name;
610 int format;
611 char *data_mime_type;
612 char *data;
613
614 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
615 ctx->ns_details_store), NULL);
616 if ((row_count > 0) && (! gtk_tree_model_get_iter_first (
617 GTK_TREE_MODEL (ctx->ns_details_store), &iter)))
618 { 306 {
619 /* This should not happen */ 307 GNUNET_break (0);
620 return; 308 return;
621 } 309 }
622 310 if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (ac->metadata),
623 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, 311 &iter, tree_path))
624 &known_iter))
625 { 312 {
626 /* This should not happen */ 313 GNUNET_break (0);
314 gtk_tree_path_free (tree_path);
627 return; 315 return;
628 } 316 }
629 317 gtk_tree_path_free (tree_path);
630 md = GNUNET_CONTAINER_meta_data_create (); 318 if ( (NULL != new_text) &&
631 319 (0 != strlen (new_text)) )
632 for (i = 0; i < row_count; i++) 320 gtk_list_store_set (ac->metadata, &iter,
633 { 321 METADATA_MC_VALUE, new_text,
634 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_details_store), &iter, 322 -1);
635 GNUNET_GTK_NAMESPACE_DETAILS_PLUGIN_NAME_COLUMN, &plugin_name, 323 else
636 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_BIN_COLUMN, &type, 324 gtk_list_store_remove (ac->metadata, &iter);
637 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, &type_name,
638 GNUNET_GTK_NAMESPACE_DETAILS_FORMAT_COLUMN, &format,
639 GNUNET_GTK_NAMESPACE_DETAILS_DATA_MIME_COLUMN, &data_mime_type,
640 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, &data,
641 -1);
642 GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
643 type, format, data_mime_type, data, strlen (data) + 1);
644 g_free (plugin_name);
645 g_free (type_name);
646 g_free (data_mime_type);
647 g_free (data);
648 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
649 ctx->ns_details_store), &iter))
650 break;
651 }
652 GNUNET_CONTAINER_meta_data_merge (md,
653 (const struct GNUNET_CONTAINER_MetaData *) ctx->uneditable_md);
654
655 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
656 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &old_md,
657 -1);
658 GNUNET_CONTAINER_meta_data_destroy (old_md);
659 gtk_list_store_set (ctx->known_ns_store, &known_iter,
660 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, md,
661 -1);
662 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
663} 325}
664 326
665 327
328/**
329 * User edited the 'value' field for inserting meta data. Update
330 * sensitivity of the 'add' button accordingly.
331 *
332 * @param editable the widget that was edited
333 * @param user_data the 'struct AdvertiseContext'
334 */
666void 335void
667GNUNET_GTK_namespace_manager_name_text_editing_started_cb ( 336GNUNET_GTK_identity_advertise_metadata_value_entry_changed_cb (GtkEditable *editable,
668 GtkCellRenderer *renderer, GtkCellEditable *editable, gchar *path, 337 gpointer user_data)
669 gpointer user_data)
670{ 338{
671 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data; 339 struct AdvertiseContext *ac = user_data;
672 340 const char *value;
673 if (GTK_IS_ENTRY (editable)) 341 GtkEntry *value_entry;
342 GtkWidget * add_button;
343
344 value_entry = GTK_ENTRY (gtk_builder_get_object (ac->builder,
345 "GNUNET_GTK_identity_advertise_metadata_value_entry"));
346 value = gtk_entry_get_text (value_entry);
347 add_button = GTK_WIDGET (gtk_builder_get_object (ac->builder,
348 "GNUNET_GTK_identity_advertise_metadata_add_button"));
349 if ( (NULL == value) ||
350 (0 == strlen (value)) )
674 { 351 {
675 GtkTreePath *tree_path; 352 gtk_widget_set_sensitive (add_button,
676 GtkTreeIter iter; 353 FALSE);
677 char *non_unique_name = NULL;
678 GtkEntry *entry = GTK_ENTRY (editable);
679
680 tree_path = gtk_tree_path_new_from_string (path);
681 if (tree_path != NULL)
682 {
683 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->known_ns_store),
684 &iter, tree_path))
685 {
686 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
687 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, &non_unique_name,
688 -1);
689 }
690 gtk_tree_path_free (tree_path);
691 }
692 if (non_unique_name == NULL)
693 {
694 gtk_cell_editable_editing_done (editable);
695 return;
696 }
697 gtk_entry_set_text (entry, non_unique_name);
698 g_free (non_unique_name);
699 }
700}
701
702
703void
704GNUNET_GTK_namespace_manager_name_text_edited_cb (
705 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
706 gpointer user_data)
707{
708 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
709 char *unique_name;
710 GtkTreeRowReference *order_row;
711
712 if (strlen (new_text) == 0)
713 return; 354 return;
714
715 GtkTreePath *tree_path;
716 GtkTreeIter iter;
717 tree_path = gtk_tree_path_new_from_string (path);
718 if (tree_path != NULL)
719 {
720 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->known_ns_store),
721 &iter, tree_path))
722 {
723 struct GNUNET_CRYPTO_EccPublicKey *nsid;
724 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
725 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
726 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
727 -1);
728
729 unique_name = GNUNET_FS_pseudonym_name_uniquify (
730 GNUNET_FS_GTK_get_configuration (), nsid, new_text, NULL);
731
732 gtk_list_store_set (ctx->known_ns_store, &iter,
733 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, new_text,
734 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, unique_name,
735 -1);
736
737 if (order_row != NULL)
738 {
739 GtkTreeIter order_iter;
740 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter))
741 {
742 gtk_list_store_set (ctx->ns_order_store, &order_iter,
743 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, unique_name,
744 -1);
745 }
746 }
747
748 GNUNET_free (unique_name);
749 }
750 gtk_tree_path_free (tree_path);
751 }
752}
753
754
755void
756GNUNET_GTK_namespace_manager_namespace_details_type_text_edited_cb (
757 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
758 gpointer user_data)
759{
760 /* Changing metadata type is more difficult than simply entering a
761 * new string, see publication editing dialog. So this is disabled
762 * for now. In fact, it's not going to be a Text renderer when it's done.
763 */
764 /*
765 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
766 GtkTreeIter iter;
767 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->ns_details_store),
768 &iter, path))
769 {
770 gtk_list_store_set (ctx->ns_details_store, &iter,
771 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, new_text,
772 -1);
773 }
774 */
775}
776
777
778void
779GNUNET_GTK_namespace_manager_namespace_details_value_text_edited_cb (
780 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
781 gpointer user_data)
782{
783 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
784 GtkTreePath *tree_path;
785 GtkTreeIter iter;
786 tree_path = gtk_tree_path_new_from_string (path);
787 if (tree_path != NULL)
788 {
789 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->ns_details_store),
790 &iter, tree_path))
791 {
792 char *old_text;
793 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_details_store), &iter,
794 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, &old_text,
795 -1);
796 if (strcmp (old_text, new_text) != 0)
797 {
798 gtk_list_store_set (ctx->ns_details_store, &iter,
799 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, new_text,
800 -1);
801 gtk_widget_set_sensitive (ctx->details_apply_button, TRUE);
802 }
803 g_free (old_text);
804 }
805 gtk_tree_path_free (tree_path);
806 } 355 }
356 gtk_widget_set_sensitive (add_button,
357 TRUE);
807} 358}
808 359
809 360
810/** 361/**
811 * Iterator over all known pseudonyms. 362 * User clicked the 'add' button, get the type and value and update
812 * Populate "known ns" and "ns order" lists. 363 * the metadata model.
813 * 364 *
814 * @param cls closure 365 * @param button the 'add' button
815 * @param pseudonym hash code of public key of pseudonym 366 * @param user_data the 'struct AdvertiseContext'
816 * @param md meta data known about the pseudonym
817 * @param rating the local rating of the pseudonym
818 * @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
819 */ 367 */
820static int 368void
821populate_known_ns_list (void *cls, 369GNUNET_GTK_identity_advertise_metadata_add_button_clicked_cb (GtkButton * button,
822 const struct GNUNET_CRYPTO_EccPublicKey *pseudonym, 370 gpointer user_data)
823 const char *name, const char *unique_name,
824 const struct GNUNET_CONTAINER_MetaData *md,
825 int rating)
826{
827 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
828 struct GNUNET_CRYPTO_EccPublicKey *nsid;
829 char buf[1024];
830 char *ret;
831 GtkTreeIter known_iter, order_iter;
832 struct GNUNET_CONTAINER_MetaData *md_copy;
833 char *non_null_name, *non_null_unique_name;
834
835 nsid = GNUNET_new (struct GNUNET_CRYPTO_EccPublicKey);
836 *nsid = *pseudonym;
837
838 ret = GNUNET_STRINGS_data_to_string (nsid,
839 sizeof (struct GNUNET_CRYPTO_EccPublicKey),
840 buf,
841 sizeof (buf));
842 GNUNET_assert (NULL != ret);
843 ret[0] = '\0';
844
845 GNUNET_FS_pseudonym_get_info (GNUNET_FS_GTK_get_configuration (),
846 nsid, NULL, NULL, &non_null_name, NULL);
847 non_null_unique_name = GNUNET_FS_pseudonym_name_uniquify (
848 GNUNET_FS_GTK_get_configuration (), nsid, non_null_name, NULL);
849
850 md_copy = GNUNET_CONTAINER_meta_data_duplicate (md);
851
852 gtk_list_store_insert_with_values (ctx->known_ns_store, &known_iter, G_MAXINT,
853 GNUNET_GTK_KNOWN_NAMESPACES_IS_MINE_COLUMN, FALSE,
854 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, rating,
855 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, non_null_unique_name,
856 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_COLUMN, buf,
857 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, nsid,
858 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
859 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, md_copy,
860 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, non_null_name,
861 -1);
862
863 if (rating >= 0)
864 {
865 GtkTreeRowReference *rr = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (
866 ctx->known_ns_store), &known_iter);
867 gtk_list_store_insert_with_values (ctx->ns_order_store, &order_iter, G_MAXINT,
868 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, rating,
869 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, non_null_unique_name,
870 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN, buf,
871 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_BIN_COLUMN, nsid,
872 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, rr,
873 -1);
874 rr = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (ctx->ns_order_store),
875 &order_iter);
876 gtk_list_store_set (ctx->known_ns_store, &known_iter,
877 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, rr, -1);
878 }
879 GNUNET_free (non_null_name);
880 GNUNET_free (non_null_unique_name);
881
882 return GNUNET_OK;
883}
884
885
886static void
887apply_known_ns_changes (struct GNUNET_GTK_NamespaceManagerContext *ctx)
888{ 371{
372 struct AdvertiseContext *ac = user_data;
889 GtkTreeIter iter; 373 GtkTreeIter iter;
890 gint i; 374 guint type;
891 gint row_count; 375 const char *type_as_string;
892 struct GNUNET_CRYPTO_EccPublicKey *nsid; 376 const char *value;
893 char *name; 377 GtkEntry *value_entry;
894 int32_t rank; 378 GtkComboBox *type_box;
895 struct GNUNET_CONTAINER_MetaData *md; 379
896 380 type_box = GTK_COMBO_BOX (gtk_builder_get_object (ac->builder,
897 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL ( 381 "GNUNET_GTK_identity_advertise_metadata_type_combobox"));
898 ctx->known_ns_store), NULL); 382 if (! gtk_combo_box_get_active_iter (type_box,
899 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL ( 383 &iter))
900 ctx->known_ns_store), &iter))
901 return;
902
903 for (i = 0; i < row_count; i++)
904 {
905 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
906 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
907 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, &name,
908 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
909 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, &rank,
910 -1);
911 GNUNET_FS_pseudonym_set_info (GNUNET_FS_GTK_get_configuration (),
912 nsid, name, md, rank);
913 g_free (name);
914 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
915 ctx->known_ns_store), &iter))
916 break;
917 }
918#if FIXME_NAMESPACE_REMOVAL
919 while (NULL != ctx->deleted_namespaces)
920 { 384 {
921 nsid = ctx->deleted_namespaces->data; 385 GNUNET_break (0);
922 if (nsid)
923 {
924 GNUNET_FS_pseudonym_remove (GNUNET_FS_GTK_get_configuration (), nsid);
925 GNUNET_free (nsid);
926 }
927 ctx->deleted_namespaces = g_list_delete_link (ctx->deleted_namespaces, ctx->deleted_namespaces);
928 }
929#endif
930}
931
932
933static void
934free_lists_contents (struct GNUNET_GTK_NamespaceManagerContext *ctx)
935{
936 GtkTreeIter iter;
937 gint i;
938 gint row_count;
939 struct GNUNET_CRYPTO_EccPublicKey *nsid;
940 GtkTreeRowReference *order_row;
941 struct GNUNET_CONTAINER_MetaData *md;
942
943 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
944 ctx->known_ns_store), NULL);
945 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
946 ctx->known_ns_store), &iter))
947 return; 386 return;
948
949 for (i = 0; i < row_count; i++)
950 {
951 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
952 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
953 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
954 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
955 -1);
956 /* Make sure the store does not contain references to freed objects */
957 gtk_list_store_set (ctx->known_ns_store, &iter,
958 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, NULL,
959 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
960 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, NULL,
961 -1);
962 if (order_row != NULL)
963 {
964 GtkTreeIter order_iter;
965 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter))
966 {
967 GtkTreeRowReference *known_row;
968 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &order_iter,
969 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row,
970 -1);
971 if (known_row != NULL)
972 gtk_tree_row_reference_free (known_row);
973 }
974 gtk_tree_row_reference_free (order_row);
975 }
976 GNUNET_CONTAINER_meta_data_destroy (md);
977 GNUNET_free (nsid);
978 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
979 ctx->known_ns_store), &iter))
980 break;
981 }
982
983 gtk_list_store_clear (ctx->ns_order_store);
984 gtk_list_store_clear (ctx->known_ns_store);
985 gtk_list_store_clear (ctx->ns_details_store);
986 if (ctx->uneditable_md != NULL)
987 GNUNET_CONTAINER_meta_data_destroy (ctx->uneditable_md);
988}
989
990
991void
992GNUNET_GTK_namespace_manager_dialog_response_cb (GtkDialog *dialog,
993 gint response_id, gpointer user_data)
994{
995 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
996 switch (response_id)
997 {
998 case GTK_RESPONSE_APPLY:
999 case GTK_RESPONSE_OK:
1000 apply_known_ns_changes (ctx);
1001 GNUNET_GTK_main_window_refresh_ns_list (ctx->main_ctx);
1002 break;
1003 default:
1004 break;
1005 } 387 }
1006 switch (response_id) 388 gtk_tree_model_get (GTK_TREE_MODEL (ac->meta_types),
389 &iter,
390 METATYPES_MC_TYPE_AS_ENUM, &type,
391 -1);
392 type_as_string = EXTRACTOR_metatype_to_string (type);
393 value_entry = GTK_ENTRY (gtk_builder_get_object (ac->builder,
394 "GNUNET_GTK_identity_advertise_metadata_value_entry"));
395 value = gtk_entry_get_text (value_entry);
396 if ( (NULL == value) ||
397 (0 == strlen (value)) )
1007 { 398 {
1008 case GTK_RESPONSE_APPLY: 399 GNUNET_break (0);
1009 break; 400 return;
1010 case GTK_RESPONSE_OK:
1011 case GTK_RESPONSE_CANCEL:
1012 default:
1013 free_lists_contents (ctx);
1014 gtk_widget_destroy (GTK_WIDGET (ctx->namespace_manager));
1015 GNUNET_free (ctx);
1016 } 401 }
1017} 402 gtk_list_store_insert_with_values (ac->metadata,
1018 403 &iter, 0,
1019 404 METADATA_MC_TYPE_AS_ENUM, type,
1020static gboolean 405 METADATA_MC_TYPE_AS_STRING, type_as_string,
1021mark_as_mine (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, 406 METADATA_MC_VALUE, value,
1022 gpointer data) 407 -1);
1023{ 408 gtk_entry_set_text (value_entry, "");
1024 const struct GNUNET_CRYPTO_EccPublicKey *mine_id = data;
1025 const struct GNUNET_CRYPTO_EccPublicKey *ns_id;
1026
1027 gtk_tree_model_get (model, iter,
1028 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &ns_id, -1);
1029
1030 if (memcmp (ns_id, mine_id, sizeof (struct GNUNET_CRYPTO_EccPublicKey)) != 0)
1031 return FALSE;
1032
1033 gtk_list_store_set (GTK_LIST_STORE (model), iter,
1034 GNUNET_GTK_KNOWN_NAMESPACES_IS_MINE_COLUMN, TRUE, -1);
1035 return TRUE;
1036} 409}
1037 410
1038 411
1039/** 412/**
1040 * Callback with information about local (!) namespaces. 413 * Run the dialog for advertising a namespace.
1041 * Contains the names of the local namespace and the global
1042 * ID.
1043 * 414 *
1044 * @param cls closure 415 * @param priv private key of the namespace to advertise
1045 * @param name human-readable identifier of the namespace
1046 * @param id hash identifier for the namespace
1047 */ 416 */
1048static void 417void
1049mark_namespaces_as_mine (void *cls, const char *name, 418GIG_advertise_dialog_start_ (const struct GNUNET_CRYPTO_EccPrivateKey *priv)
1050 const struct GNUNET_CRYPTO_EccPublicKey *id)
1051{
1052 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
1053
1054 gtk_tree_model_foreach (GTK_TREE_MODEL (ctx->known_ns_store), mark_as_mine,
1055 (gpointer) id);
1056}
1057
1058
1059/**
1060 * Type of a function that libextractor calls for each
1061 * meta data item found.
1062 *
1063 * @param cls closure (user-defined)
1064 * @param plugin_name name of the plugin that produced this value;
1065 * special values can be used (i.e. '&lt;zlib&gt;' for zlib being
1066 * used in the main libextractor library and yielding
1067 * meta data).
1068 * @param type libextractor-type describing the meta data
1069 * @param format basic format information about data
1070 * @param data_mime_type mime-type of data (not of the original file);
1071 * can be NULL (if mime-type is not known)
1072 * @param data actual meta-data found
1073 * @param data_len number of bytes in data
1074 * @return 0 to continue extracting, 1 to abort
1075 */
1076static int
1077populate_details_list (void *cls, const char *plugin_name,
1078 enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format,
1079 const char *data_mime_type, const char *data, size_t data_len)
1080{
1081 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
1082 const char *type_name;
1083 char *data_utf8;
1084
1085 if (format == EXTRACTOR_METAFORMAT_UTF8 ||
1086 format == EXTRACTOR_METAFORMAT_C_STRING)
1087 {
1088 type_name = EXTRACTOR_metatype_to_string (type);
1089 /* TODO: translate type_name using dgettext? */
1090 data_utf8 = GNUNET_FS_GTK_dubious_meta_to_utf8 (format, data, data_len);
1091 if (data != NULL)
1092 {
1093 gtk_list_store_insert_with_values (ctx->ns_details_store, NULL, G_MAXINT,
1094 GNUNET_GTK_NAMESPACE_DETAILS_PLUGIN_NAME_COLUMN, plugin_name,
1095 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_BIN_COLUMN, type,
1096 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, type_name,
1097 GNUNET_GTK_NAMESPACE_DETAILS_FORMAT_COLUMN,
1098 EXTRACTOR_METAFORMAT_UTF8,
1099 GNUNET_GTK_NAMESPACE_DETAILS_DATA_MIME_COLUMN, data_mime_type,
1100 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, data_utf8,
1101 -1);
1102 GNUNET_free (data_utf8);
1103 return 0;
1104 }
1105 }
1106 GNUNET_CONTAINER_meta_data_insert (ctx->uneditable_md,
1107 plugin_name, type, format, data_mime_type, data, data_len);
1108 return 0;
1109}
1110
1111
1112static void
1113ns_details_selection_changed (GtkTreeSelection *treeselection,
1114 gpointer user_data)
1115{
1116 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
1117 GtkTreeIter iter;
1118
1119 if (FALSE == gtk_tree_selection_get_selected (ctx->ns_details_sel, NULL, &iter))
1120 {
1121 gtk_widget_set_sensitive (ctx->details_delete_button, FALSE);
1122 return;
1123 }
1124
1125 gtk_widget_set_sensitive (ctx->details_delete_button, TRUE);
1126}
1127
1128
1129static void
1130known_ns_selection_changed (GtkTreeSelection *treeselection,
1131 gpointer user_data)
1132{ 419{
1133 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data; 420 struct AdvertiseContext *ac;
421 gint i;
1134 GtkTreeIter iter; 422 GtkTreeIter iter;
1135 const struct GNUNET_CONTAINER_MetaData *md;
1136
1137 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &iter))
1138 return;
1139 423
1140 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter, 424 ac = GNUNET_new (struct AdvertiseContext);
1141 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md, 425 ac->priv = *priv;
1142 -1); 426 ac->builder =
1143 if (ctx->uneditable_md != NULL) 427 GNUNET_GTK_get_new_builder ("gnunet_identity_gtk_advertise_dialog.glade",
1144 GNUNET_CONTAINER_meta_data_clear (ctx->uneditable_md); 428 ac);
1145 else 429 if (NULL == ac->builder)
1146 ctx->uneditable_md = GNUNET_CONTAINER_meta_data_create ();
1147 gtk_list_store_clear (ctx->ns_details_store);
1148 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
1149 if (NULL != md)
1150 GNUNET_CONTAINER_meta_data_iterate ((const struct GNUNET_CONTAINER_MetaData *) md,
1151 populate_details_list, ctx);
1152 else
1153 GNUNET_break (0);
1154 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
1155}
1156
1157
1158GtkWindow *
1159GNUNET_GTK_namespace_manager_open (struct GNUNET_GTK_MainWindowContext *main_ctx)
1160{
1161 struct GNUNET_GTK_NamespaceManagerContext *ctx;
1162
1163 ctx = GNUNET_new (struct GNUNET_GTK_NamespaceManagerContext);
1164 ctx->builder = GNUNET_GTK_get_new_builder ("gnunet_fs_gtk_namespace_manager.glade", ctx);
1165 if (ctx->builder == NULL)
1166 { 430 {
1167 GNUNET_break (0); 431 GNUNET_break (0);
1168 GNUNET_free (ctx); 432 GNUNET_free (ac);
1169 return NULL; 433 return;
1170 } 434 }
1171 435 ac->dialog = GTK_WIDGET (gtk_builder_get_object
1172 ctx->main_ctx = main_ctx; 436 (ac->builder, "GNUNET_GTK_identity_advertise_dialog"));
1173 437 ac->keywords = GTK_LIST_STORE (gtk_builder_get_object
1174 /* initialize widget references */ 438 (ac->builder, "GNUNET_GTK_identity_advertise_keywords_liststore"));
1175 ctx->known_ns = GTK_WIDGET (gtk_builder_get_object (ctx->builder, 439 ac->metadata = GTK_LIST_STORE (gtk_builder_get_object
1176 "GNUNET_GTK_namespace_manager_known_treeview")); 440 (ac->builder, "GNUNET_GTK_identity_advertise_metadata_liststore"));
1177 ctx->ns_order = GTK_WIDGET (gtk_builder_get_object (ctx->builder, 441 ac->meta_types = GTK_LIST_STORE (gtk_builder_get_object
1178 "GNUNET_GTK_namespace_manager_namespace_order_treeview")); 442 (ac->builder, "GNUNET_GTK_identity_metadata_types_liststore"));
1179 ctx->ns_details = GTK_WIDGET (gtk_builder_get_object (ctx->builder, 443 for (i = 0; EXTRACTOR_METATYPE_RESERVED != types[i]; i++)
1180 "GNUNET_GTK_namespace_manager_namespace_details_treeview"));
1181 ctx->known_ns_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
1182 ctx->known_ns));
1183 ctx->ns_order_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
1184 ctx->ns_order));
1185 ctx->ns_details_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
1186 ctx->ns_details));
1187 ctx->ns_order_store = GTK_LIST_STORE (gtk_tree_view_get_model (
1188 GTK_TREE_VIEW (ctx->ns_order)));
1189 ctx->known_ns_store = GTK_LIST_STORE (gtk_tree_view_get_model (
1190 GTK_TREE_VIEW (ctx->known_ns)));
1191 ctx->ns_details_store = GTK_LIST_STORE (gtk_tree_view_get_model (
1192 GTK_TREE_VIEW (ctx->ns_details)));
1193 ctx->namespace_manager = GTK_WINDOW (gtk_builder_get_object (
1194 ctx->builder, "GNUNET_GTK_namespace_manager_dialog"));
1195 ctx->details_apply_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
1196 "GNUNET_GTK_namespace_manager_namespace_details_apply_button"));
1197 ctx->details_delete_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
1198 "GNUNET_GTK_namespace_manager_namespace_details_delete_button"));
1199 ctx->order_rank = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 0);
1200 ctx->order_name = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 1);
1201 ctx->order_id = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 2);
1202
1203 /* connect signals; FIXME-GTK3: these could be connected with (modern) Glade */
1204 g_signal_connect (G_OBJECT (ctx->known_ns_sel), "changed",
1205 G_CALLBACK (known_ns_selection_changed), ctx);
1206 g_signal_connect (G_OBJECT (ctx->ns_details_sel), "changed",
1207 G_CALLBACK (ns_details_selection_changed), ctx);
1208
1209 /* populate namespace model */
1210 (void) GNUNET_FS_pseudonym_list_all (GNUNET_FS_GTK_get_configuration (),
1211 populate_known_ns_list, ctx);
1212
1213#if FIXME_USE_IDENTITY_SERVICE
1214 /* mark our own namespaces as such */
1215 GNUNET_FS_namespace_list (GNUNET_FS_GTK_get_fs_handle (),
1216 &mark_namespaces_as_mine, ctx);
1217#endif
1218
1219 /* sort namespace order list by rank (initially) */
1220 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN);
1221
1222 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
1223
1224 /* show dialog */
1225 gtk_window_present (ctx->namespace_manager);
1226 return ctx->namespace_manager;
1227}
1228
1229
1230static void
1231ns_manager_deleted (GtkWindow *object, gpointer user_data)
1232{
1233 struct GNUNET_GTK_MainWindowContext *ctx = user_data;
1234 g_signal_handler_disconnect (object, ctx->ns_manager_delete_handler_id);
1235 g_object_unref (G_OBJECT (ctx->ns_manager));
1236 ctx->ns_manager = NULL;
1237 ctx->ns_manager_delete_handler_id = 0;
1238 return;
1239}
1240
1241
1242void
1243GNUNET_GTK_open_ns_manager (struct GNUNET_GTK_MainWindowContext *ctx)
1244{
1245 if (ctx->ns_manager != NULL)
1246 { 444 {
1247 gtk_window_present (ctx->ns_manager); 445 gtk_list_store_insert_with_values (ac->meta_types,
1248 return; 446 &iter, G_MAXINT,
447 METATYPES_MC_TYPE_AS_STRING,
448 EXTRACTOR_metatype_to_string (types[i]),
449 METATYPES_MC_TYPE_AS_ENUM,
450 types[i],
451 -1);
452 if (0 == i)
453 gtk_combo_box_set_active_iter (GTK_COMBO_BOX
454 (gtk_builder_get_object
455 (ac->builder,
456 "GNUNET_GTK_identity_advertise_metadata_type_combobox")),
457 &iter);
1249 } 458 }
1250 459 gtk_list_store_insert_with_values (ac->keywords,
1251 ctx->ns_manager = GNUNET_GTK_namespace_manager_open (ctx); 460 &iter, G_MAXINT,
1252 if (ctx->ns_manager == NULL) 461 KEYWORDS_MC_KEYWORD, NEW_KEYWORD_TEXT,
1253 return; 462 -1);
1254 463 gtk_window_present (GTK_WINDOW (ac->dialog));
1255 g_object_ref (G_OBJECT (ctx->ns_manager));
1256 ctx->ns_manager_delete_handler_id = g_signal_connect (G_OBJECT (ctx->ns_manager), "destroy", G_CALLBACK (ns_manager_deleted), ctx);
1257}
1258
1259
1260void
1261GNUNET_GTK_main_menu_file_manage_pseudonyms_activate_cb (GtkMenuItem *menuitem,
1262 gpointer user_data)
1263{
1264 GNUNET_GTK_open_ns_manager (user_data);
1265} 464}
1266 465
1267 466
1268void
1269namespace_selector_manage_namespaces_button_clicked_cb (GtkButton *button, gpointer user_data)
1270{
1271 GNUNET_GTK_open_ns_manager (user_data);
1272}
1273#endif
1274
1275/* end of gnunet-identity-gtk_advertise.c */ 467/* end of gnunet-identity-gtk_advertise.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-03 04:16:53 +0000