path: root/src/fs/gnunet-fs-gtk_main-window-namespace-dropdown.c

/*
     This file is part of GNUnet
     (C) 2011, 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_main-window-namespace-dropdown.c
 * @author LRN
 * @brief event handlers for the namespace selection dropdown box in the main window
 */
#include "gnunet-fs-gtk_common.h"
#include "gnunet-fs-gtk.h"

/**
 *
 */
static guint namespace_selector_window_leave_timeout_source;


/**
 *
 * @param user_data the builder for the main window
 */
void
GNUNET_FS_GTK_search_namespace_dropdown_button_toggled_cb (GtkToggleButton *
							   togglebutton,
							   gpointer user_data)
{
  GtkBuilder *builder = GTK_BUILDER (user_data);
  gboolean active;
  GtkWidget *namespace_selector_window;
  GtkWidget *namespace_selector_treeview;

  namespace_selector_window =
      GTK_WIDGET (gtk_builder_get_object
                  (builder, "namespace_selector_window"));
  namespace_selector_treeview =
      GTK_WIDGET (gtk_builder_get_object
                  (builder, "namespace_selector_treeview"));
  g_object_get (G_OBJECT (togglebutton), "active", &active, NULL);
  if (active)
  {
    GtkAllocation togglebutton_allocation;
    GdkWindow *main_window_gdk;
    gint mwg_x;
    gint mwg_y;
    gint tgb_x;
    gint tgb_y;
    gint popup_x;
    gint popup_y;

    gtk_widget_get_allocation (GTK_WIDGET (togglebutton),
                               &togglebutton_allocation);

    main_window_gdk = gtk_widget_get_window (GTK_WIDGET (togglebutton));

    gdk_window_get_origin (main_window_gdk, &mwg_x, &mwg_y);

    /* FIXME: this might become a problem in other window managers,
     * where reference point is not in the top-left corner.
     * We want to show the window below the button.
     */
    tgb_x = mwg_x + togglebutton_allocation.x;
    tgb_y = mwg_y + togglebutton_allocation.y;
    popup_x = tgb_x;
    popup_y = tgb_y + togglebutton_allocation.height;

    gtk_window_move (GTK_WINDOW (namespace_selector_window), popup_x, popup_y);

    gtk_widget_show_all (namespace_selector_window);
    gtk_widget_grab_focus (namespace_selector_treeview);
  }
  else
  {
    gtk_widget_hide (namespace_selector_window);
    gtk_widget_grab_focus (GTK_WIDGET (togglebutton));
  }
}


/**
 *
 * @param user_data the builder for the main window
 */
gboolean
GNUNET_FS_GTK_search_namespace_dropdown_button_enter_notify_event_cb (GtkWidget *widget,
								      GdkEvent *event,
								      gpointer user_data)
{
  if (namespace_selector_window_leave_timeout_source > 0)
    g_source_remove (namespace_selector_window_leave_timeout_source);
  return FALSE;
}


/**
 *
 * @param user_data the builder for the main window
 */
static gboolean
namespace_selector_window_leave_timeout_cb (gpointer user_data)
{
  GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (user_data);

  /* This will eventually hide the namespace selector */
  gtk_toggle_button_set_active (toggle_button, FALSE);
  return FALSE;
}


/**
 *
 * @param user_data the builder for the main window
 */
gboolean
GNUNET_FS_GTK_namespace_selector_window_leave_notify_event_cb (GtkWidget * widget,
							       GdkEvent * event,
							       gpointer user_data)
{
  GtkBuilder *builder;
  GtkToggleButton *toggle_button;
  guint timeout_id;

  builder = GTK_BUILDER (user_data);

  toggle_button =
      GTK_TOGGLE_BUTTON (gtk_builder_get_object
                         (builder,
                          "main_window_search_namespace_dropdown_button"));

  /* Place a timeout to hide the window. It will be cancelled if the cursor
   * enters the namespace selector window or the toggle button within 100ms.
   */
  timeout_id =
      g_timeout_add (100, &namespace_selector_window_leave_timeout_cb,
                     toggle_button);
  if (namespace_selector_window_leave_timeout_source > 0)
    g_source_remove (namespace_selector_window_leave_timeout_source);
  namespace_selector_window_leave_timeout_source = timeout_id;

  return FALSE;
}


/**
 *
 */
static gboolean
get_selected_namespace_treepath_iter_model_widget (GtkBuilder * builder,
                                                   GtkTreePath ** p_treepath,
                                                   GtkTreeIter * p_iter,
                                                   GtkTreeModel ** p_model,
                                                   GtkWidget ** p_widget)
{
  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GList *selected;
  GtkTreePath *treepath;
  GtkWidget *widget;

  widget =
      GTK_WIDGET (gtk_builder_get_object
                  (builder, "namespace_selector_treeview"));
  if (!widget)
    return FALSE;

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
  model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
  if (!selection || !model)
    return FALSE;

  selected = gtk_tree_selection_get_selected_rows (selection, NULL);
  if (!selected)
    return FALSE;
  if (selected->data == NULL)
  {
    g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
    g_list_free (selected);
    return FALSE;
  }
  /* Free everything except the first path, keep it */
  treepath = (GtkTreePath *) selected->data;
  selected = g_list_remove (selected, selected->data);
  g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
  g_list_free (selected);

  if (p_iter && !gtk_tree_model_get_iter (model, p_iter, treepath))
  {
    gtk_tree_path_free (treepath);
    return FALSE;
  }
  *p_treepath = treepath;
  if (p_model)
    *p_model = model;
  if (p_widget)
    *p_widget = widget;
  return TRUE;
}


/**
 *
 * @param user_data the builder for the main window
 */
static void
namespace_selector_treeview_cursor_changed_cb (GtkWidget * widget,
                                               gpointer user_data)
{
  GtkBuilder *builder  = GTK_BUILDER (user_data);
  GtkToggleButton *toggle_button;
  GtkLabel *sel_namespace_label;
  GtkTreeModel *model;
  gchar *value;
  GtkTreePath *treepath;
  GtkEntry *search_entry;
  GtkTreeRowReference *ref, *old;

  toggle_button =
      GTK_TOGGLE_BUTTON (gtk_builder_get_object
                         (builder,
                          "main_window_search_namespace_dropdown_button"));
  if (!toggle_button)
    return;

  search_entry =
      GTK_ENTRY (gtk_builder_get_object (builder, "main_window_search_entry"));
  if (!search_entry)
    return;

  if (!get_selected_namespace_treepath_iter_model_widget
      (builder, &treepath, NULL, &model, NULL))
    return;
  ref = gtk_tree_row_reference_new (model, treepath);
  old = g_object_get_data (G_OBJECT (toggle_button), "selected-row-reference");
  if (old)
    gtk_tree_row_reference_free (old);
  g_object_set_data (G_OBJECT (toggle_button), "selected-row-reference", ref);


  sel_namespace_label =
      GTK_LABEL (gtk_builder_get_object
                 (builder, "main_window_search_selected_namespace_label"));
  if (!sel_namespace_label)
    return;

  if (GNUNET_GTK_get_tree_string (GTK_TREE_VIEW (widget), treepath, 0, &value)
      && value != NULL)
  {
    gtk_label_set_text (sel_namespace_label, value);
    g_free (value);
  }
  if (GNUNET_GTK_get_tree_string (GTK_TREE_VIEW (widget), treepath, 2, &value)
      && value != NULL)
  {
    gtk_entry_set_text (search_entry, value);
    g_free (value);
  }

  gtk_tree_path_free (treepath);

  /* This will eventually hide the namespace selector */
  gtk_toggle_button_set_active (toggle_button, FALSE);
}


/**
 *
 */
static GtkTreeRowReference *
get_ns_selected_row (GtkTreeView * tree)
{
  GtkTreeSelection *sel;
  GList *rows, *row;
  GtkTreeModel *model;
  GtkTreeRowReference *ref = NULL;

  sel = gtk_tree_view_get_selection (tree);
  rows = gtk_tree_selection_get_selected_rows (sel, &model);
  for (row = rows; row; row = row->next)
  {
    ref = gtk_tree_row_reference_new (model, row->data);
    if (ref != NULL)
      break;
  }
  g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
  g_list_free (rows);
  return ref;
}


/**
 *
 * @param user_data the builder for the main window
 */
gboolean
GNUNET_FS_GTK_namespace_selector_treeview_button_press_event_cb (GtkWidget * widget,
								 GdkEvent * event,
								 gpointer user_data)
{
  GtkTreeRowReference *ref = NULL;

  ref = get_ns_selected_row (GTK_TREE_VIEW (widget));
  if (ref != NULL)
  {
    gpointer old = g_object_get_data (G_OBJECT (widget), "pushed-rowreference");

    if (old)
      gtk_tree_row_reference_free (old);
    g_object_set_data (G_OBJECT (widget), "pushed-rowreference", ref);
  }
  return FALSE;
}


/**
 *
 * @param user_data the builder for the main window
 */
gboolean
GNUNET_FS_GTK_namespace_selector_treeview_button_release_event_cb (GtkWidget * widget,
								   GdkEvent * event,
								   gpointer user_data)
{
  GtkTreeRowReference *ref = NULL;
  gpointer old = g_object_get_data (G_OBJECT (widget), "pushed-rowreference");

  ref = get_ns_selected_row (GTK_TREE_VIEW (widget));
  if (ref && old)
  {
    GtkTreePath *path_ref, *path_old;

    path_ref = gtk_tree_row_reference_get_path (ref);
    path_old = gtk_tree_row_reference_get_path (old);
    if (gtk_tree_path_compare (path_ref, path_old) == 0)
      namespace_selector_treeview_cursor_changed_cb (widget, user_data);
    if (path_ref)
      gtk_tree_path_free (path_ref);
    if (path_old)
      gtk_tree_path_free (path_old);
  }
  if (ref)
    gtk_tree_row_reference_free (ref);
  if (old)
    gtk_tree_row_reference_free (old);
  g_object_set_data (G_OBJECT (widget), "pushed-rowreference", NULL);
  return FALSE;
}


/**
 * Add pseudonym data to tree store
 *
 * @param cls closure (the 'GtkListStore')
 * @param pseudonym hash code of public key of pseudonym
 * @param md meta data known about the pseudonym
 * @param rating the local rating of the pseudonym
 * @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
 */
static int
add_namespace_to_ts (void *cls, const GNUNET_HashCode * pseudonym,
                     const struct GNUNET_CONTAINER_MetaData *md, int rating)
{
  GtkTreeStore *ts = cls;
  char *root;
  char *ns_name;
  GNUNET_HashCode *nsid;
  char *description;
  char *uris;
  char *emsg;
  struct GNUNET_FS_Uri *uri;
  GtkTreeIter iter;

  ns_name =
      GNUNET_PSEUDONYM_id_to_name (GNUNET_FS_GTK_get_configuration (),
                                   pseudonym);
  nsid = GNUNET_malloc (sizeof (GNUNET_HashCode));
  *nsid = *pseudonym;
  root = NULL;
  uris = GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_URI);
  if (uris != NULL)
  {
    emsg = NULL;
    uri = GNUNET_FS_uri_parse (uris, &emsg);
    if (uri == NULL)
      GNUNET_free (emsg);
    root = GNUNET_FS_uri_sks_get_content_id (uri);
    GNUNET_FS_uri_destroy (uri);
  }
  description =
      GNUNET_CONTAINER_meta_data_get_first_by_types (md,
                                                     EXTRACTOR_METATYPE_TITLE,
                                                     EXTRACTOR_METATYPE_BOOK_TITLE,
                                                     EXTRACTOR_METATYPE_DESCRIPTION,
                                                     EXTRACTOR_METATYPE_SUMMARY,
                                                     EXTRACTOR_METATYPE_ALBUM,
                                                     EXTRACTOR_METATYPE_COMMENT,
                                                     EXTRACTOR_METATYPE_SUBJECT,
                                                     EXTRACTOR_METATYPE_KEYWORDS,
                                                     -1);
  if (description == NULL)
    description = g_strdup (_("no description supplied"));
  else
  {
    char *utf8_desc = NULL;

    utf8_desc =
        GNUNET_FS_GTK_dubious_meta_to_utf8 (EXTRACTOR_METAFORMAT_UTF8,
                                            description, strlen (description));
    GNUNET_free (description);
    if (utf8_desc != NULL)
      description = utf8_desc;
    else
      description = NULL;
  }
  gtk_tree_store_insert_with_values (ts, &iter, NULL, G_MAXINT, 
				     0, ns_name, 
				     1, nsid, 
				     2, root,
				     3, description, 
				     -1);
  GNUNET_free (ns_name);
  GNUNET_free_non_null (root);
  GNUNET_free_non_null (description);
  return GNUNET_OK;
}


/**
 * Startup hook to initialize the namespace dropdown widget.
 *
 * @param widget the main window
 * @param user_data the builder for the main window
 */
/* FIXME-STYLE: hang up on 'realize' event of a widget closer to home? */
void
GNUNET_GTK_main_window_realize_cb (GtkWidget * widget, gpointer user_data)
{
  GtkBuilder *builder = GTK_BUILDER (user_data);
  GtkTreeIter iter;
  GtkTreeStore *namespace_treestore;

  /* FIXME: can't we do the button initialization when we create the main window? */
  /* Make sure button class is realized */
  g_type_class_unref (g_type_class_ref (GTK_TYPE_BUTTON));
  /* GNUnet main window assumes that images on buttons are visible,
   * override the theme's gtkrc setting
   */
  g_object_set (gtk_settings_get_default (), "gtk-button-images", TRUE, NULL);

  /* setup namespace treestore */
  {
    namespace_treestore =
      GTK_TREE_STORE (GNUNET_FS_GTK_get_main_window_object
                      ("main_window_search_namespace_treestore"));
    
    /* FIXME: find a way to manage pseudonyms.
     * Right now the list will be filled with ALL and ANY pseudonyms that we
     * find, these are held as files in a special directory.
     * I don't see an easy way to ignore certain pseudonyms in that directory,
     * and that require for pseudonym management. Also, pseudonyms are presented
     * in arbitrary order. We must either sort them (by name?) or let the user
     * drag them around to change the order in which they appear in the list.
     * All that is not possible with a simple "files in a directory" concept.
     */
    gtk_tree_store_insert_with_values (namespace_treestore, &iter, NULL, G_MAXINT,
				       0, "Any", 1, NULL, 2, "", 3,
				       "Do not search in any particular namespace",
				       -1);
    /* FIXME: when do we unregister? */
    GNUNET_PSEUDONYM_discovery_callback_register (GNUNET_FS_GTK_get_configuration (), 
						  &add_namespace_to_ts,
						  namespace_treestore);
  }

  /* select the first item and update the label */
  /* FIXME: is this even necessary? If the first item is "Any", we can
     just have the label have the right default, or not? */
  if (gtk_tree_model_get_iter_first
      (GTK_TREE_MODEL (namespace_treestore), &iter))
  {
    gchar *value;
    GtkLabel *sel_namespace_label;
    GtkTreePath *treepath = gtk_tree_path_new_first ();
    GtkTreeView *namespace_tree;

    namespace_tree =
      GTK_TREE_VIEW (GNUNET_FS_GTK_get_main_window_object
                     ("namespace_selector_treeview"));
    gtk_tree_selection_select_iter (gtk_tree_view_get_selection
                                    (namespace_tree), &iter);
    sel_namespace_label =
        GTK_LABEL (gtk_builder_get_object
                   (builder, "main_window_search_selected_namespace_label"));
    if (GNUNET_GTK_get_tree_string (namespace_tree, treepath, 0, &value))
      gtk_label_set_text (sel_namespace_label, value);
    gtk_tree_path_free (treepath);
  }

  /* show the window (to trigger certain events) and immediately hide it */
  {
    GtkWidget *namespace_selector_window;

    namespace_selector_window =
      GTK_WIDGET (gtk_builder_get_object
                  (builder, "namespace_selector_window"));
    gtk_widget_show (namespace_selector_window);
    gtk_widget_hide (namespace_selector_window);
  }
}


/* end of gnunet-fs-gtk_main-window-namespace-dropdown.c */