1 files changed, 240 insertions, 31 deletions

diff --git a/src/conversation/gnunet-conversation-gtk_phone.c b/src/conversation/gnunet-conversation-gtk_phone.c
index d3cf0797..addc641e 100644
--- a/src/conversation/gnunet-conversation-gtk_phone.c
+++ b/src/conversation/gnunet-conversation-gtk_phone.c
@@ -148,7 +148,17 @@ enum InCallState
   /**
    * The call is currently suspended (by us).
    */
-  IN_STATE_SUSPENDED
+  IN_STATE_SUSPENDED_LOCAL,
+
+  /**
+   * The call is currently suspended (by remote).
+   */
+  IN_STATE_SUSPENDED_REMOTE,
+
+  /**
+   * The call is currently suspended (by both).
+   */
+  IN_STATE_SUSPENDED_BOTH
 };
 
 
@@ -436,12 +446,125 @@ check_call_sensitivity ()
 
 
 /**
+ * Update sensitivity of buttons associated with the call list.
+ *
+ * @param sel selection that changed (belongs to #active_treeview)
+ */
+static void
+update_call_buttons (GtkTreeSelection *sel) 
+{
+  GtkTreeIter iter;
+  GtkTreeModel *model;
+  gint type;
+  gint in_state;
+  gint out_state;
+  gboolean in_call;
+
+  if (! gtk_tree_selection_get_selected (sel,
+                                         &model,
+                                         &iter))
+  {
+    /* nothing selected, disable buttons */
+    gtk_widget_set_sensitive (b_add_contact, FALSE); 
+    gtk_widget_set_sensitive (b_accept, FALSE);
+    gtk_widget_set_sensitive (b_refuse, FALSE);
+    gtk_widget_set_sensitive (b_resume, FALSE);
+    return;
+  }
+  in_call = (NULL != active_in) || (NULL != active_out);
+  gtk_tree_model_get (model,
+                      &iter,
+                      GCG_PHONE_LS_TYPE, &type,
+                      GCG_PHONE_LS_CALL_STATE, &out_state,
+                      GCG_PHONE_LS_CALLER_STATE, &in_state,
+                      -1);
+  switch ((enum TypeOfConversation) type)
+  {
+  case CALL_IN:
+    switch ((enum InCallState) in_state)
+    {
+    case IN_STATE_NONE:
+      GNUNET_break (0);
+      break;
+    case IN_STATE_RINGING:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, ! in_call);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, ! in_call);
+      break;
+    case IN_STATE_CONNECTED:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, FALSE);
+      gtk_widget_set_sensitive (b_resume, FALSE);
+      break;
+    case IN_STATE_SUSPENDED_LOCAL:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, TRUE);
+    case IN_STATE_SUSPENDED_REMOTE:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, FALSE);
+    case IN_STATE_SUSPENDED_BOTH:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, TRUE);
+      break;
+    default:
+      GNUNET_assert (0);
+    }
+    break;
+  case CALL_OUT:
+    switch ((enum OutCallState) out_state)
+    {
+    case OUT_STATE_NONE:
+      GNUNET_break (0);
+      break;
+    case OUT_STATE_RESOLVING:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, FALSE);
+    case OUT_STATE_RINGING:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, ! in_call);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, ! in_call);
+    case OUT_STATE_ACTIVE:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, FALSE);
+      gtk_widget_set_sensitive (b_refuse, FALSE);
+      gtk_widget_set_sensitive (b_resume, FALSE);
+    case OUT_STATE_SUSPENDED:
+      gtk_widget_set_sensitive (b_add_contact, TRUE); 
+      gtk_widget_set_sensitive (b_accept, ! in_call);
+      gtk_widget_set_sensitive (b_refuse, TRUE);
+      gtk_widget_set_sensitive (b_resume, ! in_call);
+    default:
+      GNUNET_assert (0);
+    }
+    break;
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+/**
  * @brief executed when selecting a different item in active call list
+ *
+ * @param sel selection that changed (belongs to #active_treeview)
+ * @param user_data builder context (unused)
  */
 void
-gnunet_conversation_gtk_active_calls_treeview_selection_changed_cb ()
+gnunet_conversation_gtk_active_calls_treeview_selection_changed_cb  (GtkTreeSelection *sel,
+                                                                     gpointer user_data) 
 {
-  // FIXME
+  update_call_buttons (sel);
 }
 
 
@@ -458,6 +581,7 @@ set_outgoing_call_state (struct OutgoingCall *oc,
   GtkTreePath *path;
   GtkTreeIter iter;
 
+  oc->state = state;
   path = gtk_tree_row_reference_get_path (oc->rr);
   GNUNET_assert (gtk_tree_model_get_iter (GTK_TREE_MODEL (active_liststore),
                                           &iter,
@@ -482,6 +606,7 @@ set_outgoing_call_state (struct OutgoingCall *oc,
                       &iter,
                       GCG_PHONE_LS_CALL_STATE, state,
                       -1);
+  update_call_buttons (gtk_tree_view_get_selection (active_treeview));
 }
 
 
@@ -498,6 +623,7 @@ set_incoming_call_state (struct IncomingCall *ic,
   GtkTreePath *path;
   GtkTreeIter iter;
 
+  ic->state = state;
   path = gtk_tree_row_reference_get_path (ic->rr);
   GNUNET_assert (gtk_tree_model_get_iter (GTK_TREE_MODEL (active_liststore),
                                           &iter,
@@ -513,13 +639,18 @@ set_incoming_call_state (struct IncomingCall *ic,
     break;
   case IN_STATE_CONNECTED:
     break;
-  case IN_STATE_SUSPENDED:
+  case IN_STATE_SUSPENDED_LOCAL:
+    break;
+  case IN_STATE_SUSPENDED_REMOTE:
+    break;
+  case IN_STATE_SUSPENDED_BOTH:
     break;
   }
   gtk_list_store_set (active_liststore,
                       &iter,
                       GCG_PHONE_LS_CALLER_STATE, state,
                       -1);
+  update_call_buttons (gtk_tree_view_get_selection (active_treeview));
 }
 
 
@@ -540,10 +671,12 @@ phone_event_handler (void *cls,
   GtkTreeIter iter;
   gboolean valid;
   struct IncomingCall *ic;
+  GtkTreePath *path;
 
   switch (code)
   {
   case GNUNET_CONVERSATION_EC_PHONE_RING:
+    in_ring_counter++;
     ic = GNUNET_new (struct IncomingCall);
     ic->caller = caller;
     ic->caller_id = GNUNET_strdup (caller_id);
@@ -557,40 +690,39 @@ phone_event_handler (void *cls,
                                        GCG_PHONE_LS_CALLER_STATE, IN_STATE_RINGING,
                                        GCG_PHONE_LS_TYPE, CALL_IN,
                                        -1);
-    // FIXME: initialize ic->rr
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (active_liststore),
+                                    &iter);
+    ic->rr = gtk_tree_row_reference_new (GTK_TREE_MODEL (active_liststore),
+                                         path);
+    gtk_tree_path_free (path);
     GCG_log (_("A Incoming call from `%s' with number %u\n"),
              caller_id,
              caller_num_gen);
     break;
   case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    in_ring_counter--;
     valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (active_liststore),
                                            &iter);
     GNUNET_break (valid);
     while (valid)
     {
-      gchar *str_data;
-      gint   int_data;
-      struct IncomingCall *ic;
-
       gtk_tree_model_get (GTK_TREE_MODEL (active_liststore),
                           &iter,
                           GCG_PHONE_LS_CALLER, &ic,
-                          GCG_PHONE_LS_CALLER_ID, &str_data,
-                          GCG_PHONE_LS_CALLER_NUM, &int_data,
                           -1);
       if (caller == ic->caller)
       {
-        GCG_log (_("phone hung up:%s number: %u "),
-                 str_data,
-                 int_data);
+        GCG_log (_("phone hung up: %s number: %u"),
+                 ic->caller_id,
+                 ic->caller_num);
         set_incoming_call_state (ic,
                                  IN_STATE_NONE);
         break;
       }
-      g_free (str_data);
       valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (active_liststore),
                                         &iter);
     }
+    GNUNET_break (valid);
     phone_state = PS_LISTEN;
     break;
   }
@@ -601,16 +733,17 @@ phone_event_handler (void *cls,
 /**
  * Function called with an event emitted by a caller.
  *
- * @param cls closure with the `struct CallList` of the caller
+ * @param cls closure with the `struct IncomingCall` of the caller
  * @param code type of the event issued by the caller
  */
 static void
 caller_event_handler (void *cls,
                       enum GNUNET_CONVERSATION_CallerEventCode code)
 {
-  struct IncomingCall *cl = cls;
+  struct IncomingCall *ic = cls;
+  enum InCallState is;
 
-  if (NULL == cl)
+  if (NULL == ic)
   {
     GNUNET_break (0);
     return;
@@ -618,17 +751,66 @@ caller_event_handler (void *cls,
   switch (code)
   {
   case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
-    //TODO: should this be cls? not cl->caller
-    set_incoming_call_state (cl,
-                             IN_STATE_SUSPENDED);
+    is = ic->state;
+    switch (ic->state)
+    {
+    case IN_STATE_NONE:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_RINGING:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_CONNECTED:
+      is = IN_STATE_SUSPENDED_REMOTE;
+      break;
+    case IN_STATE_SUSPENDED_LOCAL:
+      is = IN_STATE_SUSPENDED_BOTH;
+      break;
+    case IN_STATE_SUSPENDED_REMOTE:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_SUSPENDED_BOTH:
+      GNUNET_assert (0);
+      break;
+    default:
+      GNUNET_assert (0);
+      break;
+    }
+    set_incoming_call_state (ic,
+                             is);
     GCG_log (_("Call from `%s' suspended by other user\n"),
-             cl->caller_id);
+             ic->caller_id);
     break;
   case GNUNET_CONVERSATION_EC_CALLER_RESUME:
-    set_incoming_call_state(cl,
-                            IN_STATE_CONNECTED);
+    is = ic->state;
+    switch (ic->state)
+    {
+    case IN_STATE_NONE:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_RINGING:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_CONNECTED:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_SUSPENDED_LOCAL:
+      GNUNET_assert (0);
+      break;
+    case IN_STATE_SUSPENDED_REMOTE:
+      is = IN_STATE_CONNECTED;
+      break;
+    case IN_STATE_SUSPENDED_BOTH:
+      is = IN_STATE_SUSPENDED_LOCAL;
+      break;
+    default:
+      GNUNET_assert (0);
+      break;
+    }
+    set_incoming_call_state (ic,
+                             is);
     GCG_log (_("Call from `%s' resumed by other user\n"),
-             cl->caller_id);
+             ic->caller_id);
     break;
   }
   do_status();
@@ -646,6 +828,9 @@ GNUNET_CONVERSATION_GTK_on_accept_clicked (GtkButton *button,
                                            gpointer user_data)
 {
   struct IncomingCall *ic;
+  GtkTreeSelection *sel;
+  GtkTreeIter iter;
+  GtkTreeModel *model;
 
   if ( (NULL != active_in) ||
        (NULL != active_out) ||
@@ -656,7 +841,26 @@ GNUNET_CONVERSATION_GTK_on_accept_clicked (GtkButton *button,
     return;
   }
   phone_state = PS_ACCEPTED;
-  ic = NULL; // FIXME: get 'ic' from selection!
+  sel = gtk_tree_view_get_selection (active_treeview);
+  if (! gtk_tree_selection_get_selected (sel,
+                                         &model,
+                                         &iter))
+  {
+    /* accept button should not have been sensitive! */
+    GNUNET_break (0);
+    return;
+  }
+  gtk_tree_model_get (model,
+                      &iter,
+                      GCG_PHONE_LS_CALLER_STATE, &ic,
+                      -1);
+  if (NULL == ic)
+  {
+    /* accept button should not have been sensitive! */
+    GNUNET_break (0);
+    return;
+  }
+  active_in = ic;
   set_incoming_call_state (ic,
                            IN_STATE_CONNECTED);
   GCG_update_status_bar (_("Started a conversation with `%s'.\n"),
@@ -667,7 +871,6 @@ GNUNET_CONVERSATION_GTK_on_accept_clicked (GtkButton *button,
                                       speaker, mic);
   GCG_HISTORY_add (GCG_HISTORY_TYPE_ACCEPTED,
                    ic->caller_id);
-  // FIXME: update visibility properly...
   do_status ();
 }
 
@@ -800,7 +1003,7 @@ GNUNET_CONVERSATION_GTK_on_pause_clicked (GtkButton *button,
     /* incoming */
     GNUNET_CONVERSATION_caller_suspend (active_in->caller);
     set_incoming_call_state (active_in,
-                             IN_STATE_SUSPENDED);
+                             IN_STATE_SUSPENDED_LOCAL);
     active_in = NULL;
     phone_state = PS_LISTEN;
     // FIXME: visibility
@@ -990,7 +1193,8 @@ void
 GSC_PHONE_make_call (const char *arg)
 {
   struct GNUNET_IDENTITY_Ego *caller_id;
-  GtkTreeIter gtkiter;
+  GtkTreePath *path;
+  GtkTreeIter iter;
   struct OutgoingCall *oc;
 
   gtk_entry_set_text (address_entry,
@@ -1042,7 +1246,7 @@ GSC_PHONE_make_call (const char *arg)
                                     speaker, mic,
                                     &call_event_handler, oc);
   gtk_list_store_insert_with_values (active_liststore,
-                                     &gtkiter,
+                                     &iter,
                                      -1,
                                      GCG_PHONE_LS_CALLER_ID, oc->peer_name,
                                      GCG_PHONE_LS_CALLER, NULL,
@@ -1052,7 +1256,12 @@ GSC_PHONE_make_call (const char *arg)
                                      GCG_PHONE_LS_CALL, oc,
                                      GCG_PHONE_LS_CALL_NUM, call_counter,
                                      GCG_PHONE_LS_CALL_STATE, OUT_STATE_RESOLVING,
-                                     -1);
+                                     -1); 
+  path = gtk_tree_model_get_path (GTK_TREE_MODEL (active_liststore),
+                                  &iter);
+  oc->rr = gtk_tree_row_reference_new (GTK_TREE_MODEL (active_liststore),
+                                       path);   
+  gtk_tree_path_free (path);
   /* log event */
   GCG_log (_("Resolving `%s'.\n"),
            oc->peer_name);