path: root/src/gns/gnunet-gns-gtk_zone.c

/*
     This file is part of GNUnet
     (C) 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/gns/gnunet-gns-gtk_zone.c
 * @author Christian Grothoff
 * @brief everything releated to the zone tree view
 */
#include "gnunet_gtk.h"
#include "gnunet-gns-gtk.h"

#define NEW_RECORD_STR "<new record>"

enum
{
  TREE_COL_NAME = 0,
  TREE_COL_IS_PUBLIC,
  TREE_COL_RECORD_TYPE,
  TREE_COL_RECORD_TYPE_AS_STR,
  TREE_COL_EXP_TIME,
  TREE_COL_EXP_TIME_IS_REL,
  TREE_COL_EXP_TIME_AS_STR,
  TREE_COL_VAL_AS_STR,
  TREE_COL_VAL_COLOR,
  TREE_COL_NAME_IS_EDITABLE,
};

enum
{
  TYPE_LIST_TYPE = 0,
  TYPE_LIST_TYPENAME
};

/**
 * The user has selected a new record type.  Update the
 * model, possibly invalidating (marking 'red') the existing
 * value.
 *
 * @param renderer updated renderer
 * @param path the path identifying the edited cell
 * @param new_iter selected cell in the combo's model (with the record type)
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_type_cellrenderercombo_changed_cb (GtkCellRendererCombo *combo,
						  gchar *path,
						  GtkTreeIter *new_iter,
						  gpointer user_data)
{
  struct GNUNET_GNS_Context *gns = user_data;
  GtkTreeIter it;
  GtkTreeModel *tm = GTK_TREE_MODEL(gns->ts);
  guint value;
  char * v_name;

  gtk_tree_model_get(GTK_TREE_MODEL(gns->ls), new_iter, 0, &value, -1);
  gtk_tree_model_get(GTK_TREE_MODEL(gns->ls), new_iter, TYPE_LIST_TYPENAME, &v_name, -1);
  gtk_tree_model_get_iter_from_string(tm, &it, path);
  gtk_tree_store_set(gns->ts, &it,
                     TREE_COL_RECORD_TYPE, value,
                     TREE_COL_RECORD_TYPE_AS_STR, v_name,
                     -1);

  /* check if value is still valid */

}


/**
 * The user has toggled the 'public' checkmark of a cell.  Update the
 * model.
 *
 * @param renderer updated renderer
 * @param path the path identifying the edited cell
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_ispublic_cellrenderertoggle_toggled_cb (GtkCellRendererToggle *cell_renderer,
						       gchar *path,
						       gpointer user_data)
{
  struct GNUNET_GNS_Context *gns = user_data;
  GtkTreeIter it;
  GtkTreeModel *tm = GTK_TREE_MODEL(gns->ts);
  int value;

  gtk_tree_model_get_iter_from_string(tm, &it, path);
  gtk_tree_model_get(tm, &it, TREE_COL_IS_PUBLIC, &value, -1);
  gtk_tree_store_set(gns->ts, &it, TREE_COL_IS_PUBLIC, !value, -1);

  GNUNET_break (0); // FIXME, not implemented
}


/**
 * The user has edited a 'expiration' cell.  Update the model.
 *
 * @param renderer updated renderer
 * @param path the path identifying the edited cell
 * @param new_text the new expiration time
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_expiration_cellrenderertext_edited_cb (GtkCellRendererText *renderer,
						      gchar *path,
						      gchar *new_text,
						      gpointer user_data)
{
  GNUNET_break (0); // FIXME, not implemented
}


/**
 * The user has edited a 'value' cell.  Update the model,
 * including the status on the consistency of the value with
 * the type.
 *
 * @param renderer updated renderer
 * @param path the path identifying the edited cell
 * @param new_text the new value
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_value_cellrenderertext_edited_cb (GtkCellRendererText *renderer,
						 gchar *path,
						 gchar *new_text,
						 gpointer user_data)
{
  struct GNUNET_GNS_Context *gns = user_data;
  GtkTreeModel *tm = GTK_TREE_MODEL(gns->ts);
  GtkTreeIter it;
  size_t data_size;
  void * data;
  int type;

  if (0 != strcmp(new_text,""))
  {
    gtk_tree_model_get_iter_from_string(tm, &it, path);
    gtk_tree_model_get(tm, &it, TREE_COL_RECORD_TYPE, &type, -1);
    if (GNUNET_OK == GNUNET_NAMESTORE_string_to_value (type,
                                      new_text,
                                      &data,
                                      &data_size))
    {

      gtk_tree_store_set (gns->ts, &it, TREE_COL_VAL_COLOR, NULL, -1);
      gtk_tree_store_set (gns->ts, &it, TREE_COL_VAL_AS_STR, new_text, -1);
    }
    else
    {
      gtk_tree_store_set (gns->ts, &it, TREE_COL_VAL_COLOR, "red", -1);
      gtk_tree_store_set (gns->ts, &it, TREE_COL_VAL_AS_STR, new_text, -1);
    }
  }
}


/**
 * The user has edited a 'name' cell.  Update the model (and if needed
 * create another fresh line for additional records).
 *
 * @param renderer updated renderer
 * @param path the path identifying the edited cell
 * @param new_text the new name
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_name_cellrenderertext_edited_cb (GtkCellRendererText *renderer,
						gchar *path,
						gchar *new_text,
						gpointer user_data)
{
  struct GNUNET_GNS_Context *gns = user_data;
  GtkTreeIter it;
  GtkTreeModel *tm = GTK_TREE_MODEL(gns->ts);

  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "New text for `%s' is `%s'\n", path, new_text);
  if ((0 == strcmp (path, "0")) && (0 != strcmp (new_text, NEW_RECORD_STR)) )
  {
    GNUNET_break (0);
    /* update name */
    gtk_tree_model_get_iter_from_string(tm, &it, path);
    gtk_tree_store_set (gns->ts, &it, TREE_COL_NAME, new_text, -1);

    /* add a new dummy line */
    gtk_tree_store_insert_with_values (gns->ts, &it,NULL, 0,
        TREE_COL_NAME, _(NEW_RECORD_STR),
        TREE_COL_RECORD_TYPE, 1,
        TREE_COL_NAME_IS_EDITABLE, 1,
        -1);
#if 0
    gtk_tree_store_append(gns->ts, &it, NULL);
    gtk_tree_store_set(gns->ts, &it,
                       TREE_COL_NAME, new_text,
                       TREE_COL_RECORD_TYPE, 1,
                       -1);
    /* add a new name */
    gtk_tree_store_append(gns->ts, &it, NULL);
    gtk_tree_store_set(gns->ts, &it,
                       TREE_COL_NAME, new_text,
                       TREE_COL_RECORD_TYPE, 1, -1);
#endif
  }
  else
  {
    /* update name */
    gtk_tree_model_get_iter_from_string(tm, &it, path);
    gtk_tree_store_set (gns->ts, &it, TREE_COL_NAME, new_text, -1);
  }
}


/**
 * The zone treeview pop up menu is supposed to be created.
 * (Note: this is not the only method that might need to be
 * written to handle events to create pop up menus; right-clicks
 * might need to be managed separately).
 *
 * @param widget the widget
 * @param user_data unused
 * @return TRUE if a menu was activated
 */
gboolean
GNUNET_GNS_GTK_main_treeview_popup_menu_cb (GtkWidget *widget,
					    gpointer user_data)
{  
  GNUNET_break (0); // FIXME, not implemented
  return FALSE;
}

struct ZoneIteration_Context
{
  struct GNUNET_GNS_Context *gns;
  GNUNET_HashCode zone;
  struct GNUNET_NAMESTORE_ZoneIterator * it;
};


void zone_iteration_proc (void *cls,
                          const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
                          struct GNUNET_TIME_Absolute expire,
                          const char *name,
                          unsigned int rd_count,
                          const struct GNUNET_NAMESTORE_RecordData *rd,
                          const struct GNUNET_CRYPTO_RsaSignature *signature)
{
  struct ZoneIteration_Context * zc_ctx = cls;
  GtkTreeIter iter_name;
  GtkTreeIter iter_record;
  int c;
  int time_is_relative;

  char *exp;
  char *val;
  int public;

  GNUNET_assert (zc_ctx != NULL);
  if ((NULL == zone_key) && (NULL == name))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Zone `%s 'iteration done\n", GNUNET_h2s(&zc_ctx->zone));
    GNUNET_free (zc_ctx);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Zone `%s' iteration result `%s', %u records\n",
      GNUNET_h2s(&zc_ctx->zone), name, rd_count);

  GNUNET_assert(GTK_IS_TREE_STORE(zc_ctx->gns->ts));
  gtk_tree_store_append(zc_ctx->gns->ts, &iter_name, NULL);
  /*
  GtkCellRenderer *renderer ;
  g_object_set(renderer,
               "editable", FALSE,
               NULL);
*/
  gtk_tree_store_set(zc_ctx->gns->ts, &iter_name,
                     TREE_COL_NAME, name,
                     TREE_COL_NAME_IS_EDITABLE, 1,
                     -1);


  /* Append elements for records */
  for (c = 0; c < rd_count; c ++)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Record %u: type %u flags %u expiration %llu data_size %u\n",
        c, rd[c].record_type, rd[c].flags, rd[c].expiration, rd[c].data_size);

    /* Set public toggle */
    if (rd[c].flags != GNUNET_NAMESTORE_RF_PRIVATE)
      public = GNUNET_YES;
    else
      public = GNUNET_NO;

    /* Expiration time */
    time_is_relative = GNUNET_NO;

    if (GNUNET_YES == time_is_relative)
    {
      /* FIX THIS WHEN WE HAVE RELATIVE TIME */
      struct GNUNET_TIME_Relative rel_time = GNUNET_TIME_relative_get_zero();
      exp = GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), rel_time));
    }
    else
      exp = GNUNET_STRINGS_absolute_time_to_string (rd[c].expiration);
    /* value */
    val = GNUNET_NAMESTORE_value_to_string (rd[c].record_type,
                                            rd[c].data,
                                            rd[c].data_size);

    gtk_tree_store_insert_with_values(zc_ctx->gns->ts, &iter_record , &iter_name, 0,
                                       TREE_COL_NAME, "",
                                       TREE_COL_RECORD_TYPE, rd[c].record_type,
                                       TREE_COL_RECORD_TYPE_AS_STR, GNUNET_NAMESTORE_number_to_typename(rd[c].record_type),
                                       TREE_COL_IS_PUBLIC, public,
                                       TREE_COL_EXP_TIME_AS_STR, exp,
                                       TREE_COL_EXP_TIME_IS_REL, time_is_relative,
                                       TREE_COL_VAL_AS_STR, val,
                                       -1);

    GNUNET_free (exp);
  }

  GNUNET_NAMESTORE_zone_iterator_next(zc_ctx->it);
}

/**
 * The zone treeview was realized.   Setup the model.
 *
 * @param widget the widget
 * @param user_data unused
 */
void
GNUNET_GNS_GTK_main_treeview_realize_cb (GtkWidget *widget,
					 gpointer user_data)
{
  struct GNUNET_GNS_Context *gns = user_data;
  struct ZoneIteration_Context *zc_ctx;
  GtkTreeIter toplevel;

  /* Append a top level row and leave it empty */
  gtk_tree_store_insert_with_values(gns->ts, &toplevel, NULL, 0,
                                     TREE_COL_NAME, _(NEW_RECORD_STR),
                                     TREE_COL_RECORD_TYPE, 1,
                                     TREE_COL_NAME_IS_EDITABLE, 1,
                                     -1);

  zc_ctx = GNUNET_malloc (sizeof (struct ZoneIteration_Context));
  zc_ctx->gns = user_data;
  zc_ctx->zone = gns->zone;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Starting one `%s' iteration\n", GNUNET_h2s(&zc_ctx->zone));

  zc_ctx->it = GNUNET_NAMESTORE_zone_iteration_start(gns->ns, &gns->zone,
      GNUNET_NAMESTORE_RF_NONE,
      GNUNET_NAMESTORE_RF_NONE,
      &zone_iteration_proc,
      zc_ctx);
}


/* end of gnunet-gns-gtk_zone.c */