1 files changed, 781 insertions, 0 deletions

diff --git a/src/identity/gnunet-identity-gtk_ego_organizer.c b/src/identity/gnunet-identity-gtk_ego_organizer.c
new file mode 100644
index 00000000..2cf7db65
--- /dev/null
+++ b/src/identity/gnunet-identity-gtk_ego_organizer.c
@@ -0,0 +1,781 @@
+/*
+     This file is part of GNUnet
+     (C) 2005, 2006, 2010, 2012 Christian Grothoff (and other contributing authors)
+
+     GNUnet 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 2, or (at your
+     option) any later version.
+
+     GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/fs/gnunet-fs-gtk_namespace_organizer.c
+ * @author LRN
+ */
+#include "gnunet-fs-gtk_common.h"
+#include "gnunet-fs-gtk.h"
+#include "gnunet-fs-gtk_advertise-pseudonym.h"
+#include <gnunet/gnunet_util_lib.h>
+#include <gnunet/gnunet_fs_service.h>
+
+struct GNUNET_GTK_NamespaceSelectorContext
+{
+  GtkBuilder *builder;
+  GtkWidget *my_ns;
+  GtkTreeSelection *my_ns_sel;
+  GtkListStore *my_ns_store;
+  GtkWindow *namespace_organizer;
+  GtkWidget *create_button;
+  GtkWidget *delete_button;
+  GtkWidget *advertise_button;
+  GtkWidget *do_delete_button;
+  GtkWidget *do_keep_button;
+  GtkWidget *progress_spinner;
+  GtkWidget *progress_label;
+  GtkWidget *confirmation_label;
+  char *default_ns;
+  GtkTreeRowReference *default_ns_rref;
+  struct GNUNET_GTK_MainWindowContext *main_ctx;
+};
+
+#define GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN 0
+#define GNUNET_GTK_MY_NAMESPACES_KEY_COLUMN 1
+#define GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN 2
+#define GNUNET_GTK_MY_NAMESPACES_USE_THIS_COLUMN 3
+#define GNUNET_GTK_MY_NAMESPACES_ACTUAL_NAME_COLUMN 4
+
+/**
+ * User edited the name of a namespace.
+ * Rename the namespace.
+ *
+ * @param renderer cell renderer
+ * @param path path to the cell that was edited (as a string)
+ * @param new_text new contents of the cell
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_treeview_column_name_text_edited_cb (
+    GtkCellRendererText *renderer, gchar *path, gchar *new_text,
+    gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  GtkTreePath *tree_path;
+  GtkTreeIter iter;
+
+  if (strlen (new_text) == 0)
+    return;
+
+  tree_path = gtk_tree_path_new_from_string (path);
+  if (tree_path != NULL)
+  {
+    if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->my_ns_store),
+        &iter, tree_path))
+    {
+      struct GNUNET_FS_PseudonymIdentifier *nsid;
+      char *old_name;
+      gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), &iter,
+          GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, &old_name,
+          GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, &nsid,
+          -1);
+
+      if ((NULL == nsid) ||
+          (GNUNET_OK == GNUNET_FS_namespace_rename (
+              GNUNET_FS_GTK_get_fs_handle (), old_name, new_text)))
+      {
+        gtk_list_store_set (ctx->my_ns_store, &iter,
+            GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, new_text, -1);
+      }
+
+      GNUNET_free (old_name);
+    }
+    gtk_tree_path_free (tree_path);
+  }
+}
+
+/**
+ * Frees contents of the namespace list (the nsid values that are stored as
+ * untyped pointers in the tree).
+ *
+ * @param ctx NS organizer context
+ */
+static void
+free_lists_contents (struct GNUNET_GTK_NamespaceSelectorContext *ctx)
+{
+  GtkTreeIter iter;
+  gint i;
+  gint row_count;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+
+  row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
+      ctx->my_ns_store), NULL);
+  if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
+      ctx->my_ns_store), &iter))
+    return;
+
+  for (i = 0; i < row_count; i++)
+  {
+    gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), &iter,
+        GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, &nsid,
+        -1);
+    GNUNET_free (nsid);
+    if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
+      ctx->my_ns_store), &iter))
+      break;
+  }
+
+  gtk_list_store_clear (ctx->my_ns_store);
+}
+
+/**
+ * Called when dialog is being closed (for any reason).
+ *
+ * @param dialog dialog being closed
+ * @param response_id identifies the event
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_dialog_response_cb (GtkDialog *dialog,
+    gint response_id, gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  switch (response_id)
+  {
+  case GTK_RESPONSE_CLOSE:
+  default:
+    free_lists_contents (ctx);
+    gtk_widget_destroy (GTK_WIDGET (ctx->namespace_organizer));
+    GNUNET_free (ctx);
+  }
+}
+
+/**
+ * Store a reference to the default namespace for later use.
+ *
+ * @param ctx context
+ * @param iter points to the default namespace in the list
+ */
+static void
+save_default_ns_reference (struct GNUNET_GTK_NamespaceSelectorContext *ctx, GtkTreeIter *iter)
+{
+  GtkTreeRowReference *ref;
+  GtkTreePath *rowpath;
+
+  rowpath = gtk_tree_model_get_path (GTK_TREE_MODEL (ctx->my_ns_store), iter);  
+  if (rowpath)
+  {
+    ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (ctx->my_ns_store), rowpath);
+    if (ref)
+    {
+      gtk_tree_row_reference_free (ctx->default_ns_rref);
+      ctx->default_ns_rref = ref;
+    }
+    gtk_tree_path_free (rowpath);
+  }
+}
+
+
+/**
+ * Try to mark an item in the list as the default namespace.
+ *
+ * @param ctx context
+ * @param iter points to the new default namespace in the list
+ */
+static void
+try_make_default (struct GNUNET_GTK_NamespaceSelectorContext *ctx, GtkTreeIter *toggled)
+{
+  GtkTreeIter iter;
+  gchar *new_default_ns;
+  gint i;
+  gint row_count;
+  GtkTreePath *path;
+
+  row_count = gtk_tree_model_iter_n_children (
+      GTK_TREE_MODEL (ctx->my_ns_store), NULL);
+  if (! gtk_tree_model_get_iter_first (
+      GTK_TREE_MODEL (ctx->my_ns_store), &iter))
+    return;
+
+  path = gtk_tree_row_reference_get_path (ctx->default_ns_rref);
+  if (path)
+  {
+    /* We know where previous default was, only untoggle that item */
+    GtkTreeIter old_default;
+    if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->my_ns_store), &old_default, path))
+    {
+      gtk_list_store_set (ctx->my_ns_store, &old_default,
+          GNUNET_GTK_MY_NAMESPACES_USE_THIS_COLUMN, FALSE,
+          -1);
+    }
+    gtk_tree_path_free (path);
+  }
+  else
+  {
+    /* Just untoggle all items */
+    for (i = 0; i < row_count; i++)
+    {
+      gtk_list_store_set (ctx->my_ns_store, &iter,
+          GNUNET_GTK_MY_NAMESPACES_USE_THIS_COLUMN, FALSE,
+          -1);
+      if (TRUE != gtk_tree_model_iter_next (
+          GTK_TREE_MODEL (ctx->my_ns_store), &iter))
+        break;
+    }
+  }
+
+  gtk_list_store_set (ctx->my_ns_store, toggled,
+      GNUNET_GTK_MY_NAMESPACES_USE_THIS_COLUMN, TRUE, -1);
+  gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), toggled,
+      GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, &new_default_ns, -1);
+
+  save_default_ns_reference (ctx, toggled);
+
+  if (new_default_ns)
+  {
+    ctx->default_ns = GNUNET_strdup (new_default_ns);
+    GNUNET_CONFIGURATION_set_value_string (
+       (struct GNUNET_CONFIGURATION_Handle *) GNUNET_FS_GTK_get_configuration (),
+      "gnunet-fs-gtk", "DEFAULT_NAMESPACE", ctx->default_ns);
+
+    g_free (new_default_ns);
+  }
+}
+
+
+
+/**
+ * Callback with information about local (!) namespaces.
+ * Contains the names of the local namespace and the global
+ * ID.
+ *
+ * @param cls closure
+ * @param name human-readable identifier of the namespace
+ * @param id hash identifier for the namespace
+ */
+static void
+populate_my_ns_list (void *cls, const char *name,
+    const struct GNUNET_FS_PseudonymIdentifier *id)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = cls;
+
+  char buf[1024];
+  char *ret;
+  GtkTreeIter my_iter;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+  gboolean is_default;
+
+  nsid = GNUNET_malloc (sizeof (struct GNUNET_FS_PseudonymIdentifier));
+  *nsid = *id;
+
+  ret = GNUNET_STRINGS_data_to_string (nsid,
+      sizeof (struct GNUNET_FS_PseudonymIdentifier), buf, sizeof (buf));
+  GNUNET_assert (NULL != ret);
+  ret[0] = '\0';
+
+  if (NULL == ctx->default_ns)
+  {
+    ctx->default_ns = GNUNET_strdup (name);
+    GNUNET_CONFIGURATION_set_value_string (
+       (struct GNUNET_CONFIGURATION_Handle *) GNUNET_FS_GTK_get_configuration (),
+      "gnunet-fs-gtk", "DEFAULT_NAMESPACE", ctx->default_ns);
+    is_default = TRUE;
+  }
+  else
+    is_default = (0 == strcmp (name, ctx->default_ns)) ? TRUE : FALSE;
+
+  gtk_list_store_insert_with_values (ctx->my_ns_store, &my_iter, G_MAXINT,
+      GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, name,
+      GNUNET_GTK_MY_NAMESPACES_KEY_COLUMN, buf,
+      GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, nsid,
+      GNUNET_GTK_MY_NAMESPACES_USE_THIS_COLUMN, is_default,
+      GNUNET_GTK_MY_NAMESPACES_ACTUAL_NAME_COLUMN, NULL,
+      -1);
+
+  if (is_default)
+    save_default_ns_reference (ctx, &my_iter);
+}
+
+/**
+ * Returns button visibility/sensitivity to normal.
+ *
+ * @param ctx context
+ * @param anything_selected TRUE if a namespace is selected in the list,
+ *                          FALSE otherwise
+ */
+static void
+set_normal_state (struct GNUNET_GTK_NamespaceSelectorContext *ctx, gboolean anything_selected)
+{
+  gtk_widget_set_visible (ctx->do_delete_button, FALSE);
+  gtk_widget_set_visible (ctx->do_keep_button, FALSE);
+  gtk_widget_set_visible (ctx->confirmation_label, FALSE);
+
+  gtk_widget_set_sensitive (ctx->advertise_button, anything_selected);
+  gtk_widget_set_sensitive (ctx->delete_button, anything_selected);
+  gtk_widget_set_sensitive (ctx->create_button, TRUE);
+}
+
+/**
+ * Handles ns list selection changes.
+ *
+ * @param treeselection selection object
+ * @param user_data context
+ */
+static void
+my_ns_selection_changed (GtkTreeSelection *treeselection,
+    gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  GtkTreeIter iter;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+  gboolean selected;
+
+  nsid = NULL;
+  selected = gtk_tree_selection_get_selected (ctx->my_ns_sel, NULL, &iter);
+  if (selected)
+    gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), &iter,
+        GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, &nsid, -1);
+  if (NULL == nsid)
+    selected = FALSE;
+  set_normal_state (ctx, selected);
+}
+
+/**
+ * Opens the organizer dialog. Called from outside (by the main window).
+ *
+ * @param main_ctx context of the main window
+ * @return newly-created dialog window object
+ */
+GtkWindow *
+GNUNET_GTK_namespace_organizer_open (struct GNUNET_GTK_MainWindowContext *main_ctx)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx;
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  ctx = GNUNET_malloc (sizeof (struct GNUNET_GTK_NamespaceSelectorContext));
+  ctx->builder = GNUNET_GTK_get_new_builder ("gnunet_fs_gtk_namespace_organizer.glade", ctx);
+  if (ctx->builder == NULL)
+  {
+    GNUNET_break (0);
+    GNUNET_free (ctx);
+    return NULL;
+  }
+
+  ctx->main_ctx = main_ctx;
+
+  /* initialize widget references */
+  ctx->my_ns = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_treeview"));
+  ctx->my_ns_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
+      ctx->my_ns));
+  ctx->my_ns_store = GTK_LIST_STORE (gtk_tree_view_get_model (
+      GTK_TREE_VIEW (ctx->my_ns)));
+  ctx->namespace_organizer = GTK_WINDOW (gtk_builder_get_object (
+      ctx->builder, "GNUNET_GTK_namespace_organizer_dialog"));
+  ctx->create_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_create_namespace_button"));
+  ctx->advertise_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_advertise_namespace_button"));
+  ctx->delete_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_button"));
+  ctx->do_delete_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_confirmation_button"));
+  ctx->do_keep_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_unconfirmation_button"));
+  ctx->progress_spinner = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_create_namespace_progress_spinner"));
+  ctx->progress_label = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_create_namespace_progress_label"));
+  ctx->confirmation_label = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
+      "GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_confirmation_label"));
+
+  /* connect signals; FIXME-GTK3: these could be connected with (modern) Glade */
+  g_signal_connect (G_OBJECT (ctx->my_ns_sel), "changed",
+      G_CALLBACK (my_ns_selection_changed), ctx);
+
+  cfg = GNUNET_FS_GTK_get_configuration ();
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+      "gnunet-fs-gtk", "DEFAULT_NAMESPACE", &ctx->default_ns))
+    ctx->default_ns = NULL;
+
+  gtk_widget_set_sensitive (ctx->advertise_button, FALSE);
+  gtk_widget_set_sensitive (ctx->delete_button, FALSE);
+
+  gtk_widget_set_visible (ctx->do_delete_button, FALSE);
+  gtk_widget_set_visible (ctx->do_keep_button, FALSE);
+  gtk_widget_set_visible (ctx->progress_spinner, FALSE);
+  gtk_widget_set_visible (ctx->progress_label, FALSE);
+  gtk_widget_set_visible (ctx->confirmation_label, FALSE);
+
+  /* populate namespace model */
+  GNUNET_FS_namespace_list (GNUNET_FS_GTK_get_fs_handle (),
+      populate_my_ns_list, ctx);
+
+  /* show dialog */
+  gtk_window_present (ctx->namespace_organizer);
+  return ctx->namespace_organizer;
+}
+
+/**
+ * Called when the organizer dialog is destoryed
+ * (happens at some point after it's closed).
+ * Cleans up references to the organizer dialog that main window stores.
+ *
+ * @param object the object that is being destroyed
+ * @param user_data main window context
+ */
+void
+GNUNET_GTK_namespace_organizer_dialog_destroy_cb (GtkWindow *object, gpointer user_data)
+{
+  struct GNUNET_GTK_MainWindowContext *ctx = user_data;
+  g_signal_handler_disconnect (object, ctx->ns_organizer_delete_handler_id);
+  g_object_unref (G_OBJECT (ctx->ns_organizer));
+  ctx->ns_organizer = NULL;
+  ctx->ns_organizer_delete_handler_id = 0;
+  return;
+}
+
+/**
+ * Wrapper for GNUNET_GTK_namespace_organizer_open(), ensures that
+ * only one instance is opened.
+ * @param ctx main window context
+ */
+void
+GNUNET_GTK_open_ns_organizer (struct GNUNET_GTK_MainWindowContext *ctx)
+{
+  if (ctx->ns_organizer != NULL)
+  {
+    gtk_window_present (ctx->ns_organizer);
+    return;
+  }
+
+  ctx->ns_organizer = GNUNET_GTK_namespace_organizer_open (ctx);
+  if (ctx->ns_organizer == NULL)
+    return;
+
+  g_object_ref (G_OBJECT (ctx->ns_organizer));
+  ctx->ns_organizer_delete_handler_id = g_signal_connect (G_OBJECT (ctx->ns_organizer), "destroy", G_CALLBACK (GNUNET_GTK_namespace_organizer_dialog_destroy_cb), ctx);
+}
+
+/**
+ * Called when user clicks at 'Advertise namespace' button.
+ * Opens the advertising dialog (calls GNUNET_FS_GTK_advertise_namespace()).
+ *
+ * @param button button that was clicked
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_advertise_namespace_button_clicked_cb (
+    GtkButton *button, gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  GtkTreeIter iter;
+  gchar *name;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+
+  nsid = NULL;
+  name = NULL;
+  if (gtk_tree_selection_get_selected (ctx->my_ns_sel, NULL, &iter))
+    gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), &iter,
+        GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, &name, 
+        GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, &nsid,
+        -1);
+  if (NULL != nsid)
+  {
+    struct GNUNET_FS_Namespace *ns;
+    ns = GNUNET_FS_namespace_open_existing (GNUNET_FS_GTK_get_fs_handle (), name);
+    if (ns)
+      GNUNET_FS_GTK_advertise_namespace (ns, ctx->namespace_organizer);
+  }
+  g_free (name);
+}
+
+/**
+ * Called when user clicks at 'Do not delete' button.
+ * Returns the state back to normal (hides [un]confirmation buttons
+ * and the warning label).
+ *
+ * @param button button that was clicked
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_unconfirmation_button_clicked_cb (
+    GtkButton *button, gpointer user_data)
+{
+  set_normal_state (user_data, TRUE);
+}
+
+
+/**
+ * Called when user clicks at 'Do delete' button.
+ * Deletes selected namespace after double-checking that everything is
+ * in order.
+ * Returns the state back to normal (hides [un]confirmation buttons
+ * and the warning label).
+ *
+ * @param button button that was clicked
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_confirmation_button_clicked_cb (
+    GtkButton *button, gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  GtkTreeIter iter;
+  gchar *name;
+  gboolean selected;
+  struct GNUNET_FS_PseudonymIdentifier id;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+
+  nsid = NULL;
+  name = NULL;
+  selected = gtk_tree_selection_get_selected (ctx->my_ns_sel, NULL, &iter);
+  if (selected)
+    gtk_tree_model_get (GTK_TREE_MODEL (ctx->my_ns_store), &iter,
+        GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, &name, 
+        GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, &nsid,
+        -1);
+  if (NULL == nsid)
+    selected = FALSE;
+
+  if (selected)
+  {
+    struct GNUNET_FS_Namespace *ns;
+    ns = GNUNET_FS_namespace_open_existing (GNUNET_FS_GTK_get_fs_handle (), name);
+    if (ns)
+    {
+      if (GNUNET_FS_namespace_get_public_identifier (ns, &id))
+      {
+        if (0 == memcmp (&id, nsid, sizeof (id)))
+        {
+          GtkTreeIter first;
+
+          GNUNET_free (nsid);
+          gtk_list_store_remove (ctx->my_ns_store, &iter);
+          GNUNET_FS_namespace_delete (ns, GNUNET_YES);
+
+          if (gtk_tree_model_get_iter_first (
+              GTK_TREE_MODEL (ctx->my_ns_store), &first))
+            try_make_default (ctx, &first);
+        }
+        else
+        {
+          /* We were trying to delete namespace FOO with key X
+           * but when we opened FOO, we discovered that its key is Y.
+           * Clearly this is not the right namespace (something changed
+           * the namespace list right under us?).
+           */
+           /* TODO: display error message */
+          GNUNET_FS_namespace_delete (ns, GNUNET_NO);
+        }
+      }
+      else
+      {
+        /* We were trying to delete namespace FOO,
+         * but we can't even get its key
+         */
+        /* TODO: display error message */
+        GNUNET_FS_namespace_delete (ns, GNUNET_NO);
+      }
+    }
+  }
+  g_free (name);
+  set_normal_state (user_data, selected);
+}
+
+/**
+ * Called when user clicks at 'Delete' button.
+ * Shows the [un]confirmation buttons, as well as the warning.
+ *
+ * @param button button that was clicked
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_delete_namespace_button_clicked_cb (
+    GtkButton *button, gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  gtk_widget_set_visible (ctx->do_delete_button, TRUE);
+  gtk_widget_set_visible (ctx->do_keep_button, TRUE);
+  gtk_widget_set_visible (ctx->confirmation_label, TRUE);
+  gtk_widget_set_sensitive (ctx->advertise_button, FALSE);
+  gtk_widget_set_sensitive (ctx->delete_button, FALSE);
+  gtk_widget_set_sensitive (ctx->create_button, FALSE);
+}
+
+/**
+ * Generates a random ns name.
+ *
+ * @return new name (free with GNUNET_free()).
+ */
+char *
+generate_local_ns_name ()
+{
+  const char *table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  size_t tablelen = strlen (table);
+  char random_str[9];
+  char *result;
+  int i;
+  for (i = 0; i < 8; i++)
+  {
+    uint32_t index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, tablelen);
+    GNUNET_assert (index < tablelen);
+    random_str[i] = table[index];
+  }
+  random_str[8] = '\0';
+
+  GNUNET_asprintf (&result, _("MyNamespace-%s"), random_str);
+  return result;
+}
+
+
+/**
+ * Called when key generation for a namespace is finished.
+ *
+ * @param cls context
+ * @param ns newly-created namespace (NULL on failure)
+ * @param emsg error message (NULL on success)
+ */
+static void
+ns_created (void *cls, struct GNUNET_FS_Namespace *ns, char *name, const char *emsg)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = cls;
+
+  GtkTreeIter iter;
+  struct GNUNET_FS_PseudonymIdentifier *nsid;
+  struct GNUNET_FS_PseudonymIdentifier id;
+
+  /* If ns was created, get its public key hash */
+  nsid = NULL;
+  if ((NULL != ns) && (GNUNET_OK == GNUNET_FS_namespace_get_public_identifier (ns, &id)))
+  {
+    nsid = GNUNET_malloc (sizeof (struct GNUNET_FS_PseudonymIdentifier));
+    memcpy (nsid, &id, sizeof (struct GNUNET_FS_PseudonymIdentifier));
+  }
+
+  /* If anything of the above went wrong, or ns creation failed, we abort */
+  if (NULL == nsid)
+  {
+    GNUNET_FS_namespace_delete (ns, GNUNET_NO);
+  }
+  else
+  {
+    char buf[1024];
+    char *ret;
+    gint row_count;
+
+    ret = GNUNET_STRINGS_data_to_string (nsid,
+                                         sizeof (struct GNUNET_FS_PseudonymIdentifier),
+                                         buf,
+                                         sizeof (buf));
+    GNUNET_assert (NULL != ret);
+    ret[0] = '\0';
+
+    gtk_list_store_insert_with_values (ctx->my_ns_store, &iter, G_MAXINT,
+        GNUNET_GTK_MY_NAMESPACES_KEY_COLUMN, buf,
+        GNUNET_GTK_MY_NAMESPACES_KEY_BINARY_COLUMN, nsid,
+        GNUNET_GTK_MY_NAMESPACES_NAME_COLUMN, name,
+        -1);
+
+    row_count = gtk_tree_model_iter_n_children (
+        GTK_TREE_MODEL (ctx->my_ns_store), NULL);
+    if (row_count == 1)
+      try_make_default (ctx, &iter);
+  }
+}
+
+
+/**
+ * Create a namespace.
+ * Adds a dummy to the list, starts the key generation process,
+ * shows the progress spinner, disables some buttons.
+ *
+ * @param ctx context
+ */
+static void
+create_namespace (struct GNUNET_GTK_NamespaceSelectorContext *ctx)
+{
+  gchar *name;
+  struct GNUNET_FS_Namespace *ns;
+
+  ns = NULL;
+  name = NULL;
+  do
+  {
+    if (ns)
+      GNUNET_FS_namespace_delete (ns, GNUNET_NO);
+    GNUNET_free_non_null (name);
+    name = generate_local_ns_name ();
+    ns = GNUNET_FS_namespace_open_existing (GNUNET_FS_GTK_get_fs_handle (), name);
+  } while (NULL != ns);
+
+  ns = GNUNET_FS_namespace_create (GNUNET_FS_GTK_get_fs_handle (), name);
+
+  if (NULL == ns)
+  {
+    GNUNET_free (name);
+    return;
+  }
+
+  ns_created (ctx, ns, name, NULL);
+
+  GNUNET_free (name);
+}
+
+/**
+ * Called when user clicks at 'Create' button.
+ * Creates a namespace.
+ *
+ * @param button button that was clicked
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_create_namespace_button_clicked_cb (
+    GtkButton *button, gpointer user_data)
+{
+  create_namespace (user_data);
+}
+
+/**
+ * Called when user toggles the radio button at a namespace in the list
+ * Tries to make that namespace the new default.
+ *
+ * @param cell_renderer renderer of the call that was toggled.
+ * @param path path to the cell that was toggled
+ * @param user_data context
+ */
+void
+GNUNET_GTK_namespace_organizer_namespaces_treeview_column_usethis_toggle_toggled_cb (
+    GtkCellRendererToggle *cell_renderer, gchar *path, gpointer user_data)
+{
+  struct GNUNET_GTK_NamespaceSelectorContext *ctx = user_data;
+  GtkTreeIter iter;
+  if (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (ctx->my_ns_store),
+      &iter, path))
+    try_make_default (ctx, &iter);
+}
+
+/**
+ * Called when user activates the appropriate item in main window `File' menu.
+ * Opens Namespace organizer dialog.
+ *
+ * @param menuitem item that was activated
+ * @param user_data main window context
+ */
+void
+GNUNET_GTK_main_menu_file_organize_namespaces_activate_cb (GtkMenuItem *menuitem,
+    gpointer user_data)
+{
+  GNUNET_GTK_open_ns_organizer (user_data);
+}
+
+/* end of gnunet-fs-gtk_namespace_organizer.c */