actions.c

/*
 *  Copyright (C) 2007 Savoir-Faire Linux inc.
 *  Author: Pierre-Luc Beaudoin <pierre-luc@squidy.info>
 *                                                                              
 *  This program 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 of the License, or
 *  (at your option) any later version.
 *                                                                                
 *  This program 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 this program; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <accountlist.h>
#include <actions.h>
#include <calltree.h>
#include <dbus.h>
#include <mainwindow.h>
#include <menus.h>
#include <screen.h>
#include <statusicon.h>

#include <gtk/gtk.h>
#include <string.h>
#include <glib/gprintf.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>


void
sflphone_notify_voice_mail (guint count)
{
  if(count > 0)
  {
    gchar * message = g_new0(gchar, 50);
    g_sprintf(message, "%d new voice mail%s", count, (count > 1? "s" : "")); 
    status_bar_message(message);
    g_free(message);
  }
  else
  {
    status_bar_message("");
  }
}

gboolean
sflphone_quit ()
{
  gboolean quit = FALSE;
  guint count = call_list_get_size();
  if(count > 0){
    quit = main_window_ask_quit();
  }
  else{
    quit = TRUE;
  }
  
  if (quit)
  {
    dbus_unregister(getpid());
    dbus_clean ();
    //call_list_clean(); TODO
    //account_list_clean()
    gtk_main_quit ();
  }
  return quit;
}

void 
sflphone_hold(call_t * c )
{
  c->state = CALL_STATE_HOLD;
  update_call_tree(c);
  update_menus();
  screen_clear();
}

void 
sflphone_ringing(call_t * c )
{
  c->state = CALL_STATE_RINGING;
  update_call_tree(c);
  update_menus();
}

/** Internal to actions: Fill account list */
void
sflphone_fill_account_list()
{
  account_list_clear ( );
  
  gchar ** array = (gchar **)dbus_account_list();
  gchar ** accountID;
  for (accountID = array; *accountID; accountID++)
  {
    account_t * a = g_new0(account_t,1);
    a->accountID = g_strdup(*accountID);
    account_list_add(a);
  }
  g_strfreev (array);
  
  int i;
  for( i = 0; i < account_list_get_size(); i++)
	{
    account_t  * a = account_list_get_nth (i);
    GHashTable * details = (GHashTable *) dbus_account_details(a->accountID);
    a->properties = details;
    
    gchar * status = g_hash_table_lookup(details, "Status");
    if(strcmp(status, "REGISTERED") == 0)
    {
      a->state = ACCOUNT_STATE_REGISTERED;
    }
    else if(strcmp(status, "UNREGISTERED") == 0)
    {
      a->state = ACCOUNT_STATE_UNREGISTERED;
    }
    else if(strcmp(status, "TRYING") == 0)
    {
      a->state = ACCOUNT_STATE_TRYING;
    }
    else if(strcmp(status, "ERROR") == 0)
    {
      a->state = ACCOUNT_STATE_ERROR;
    }
    else
    {
      a->state = ACCOUNT_STATE_INVALID;
    }
    
  }
  
	toolbar_update_buttons();
}

gboolean
sflphone_init()
{
  call_list_init ();
  account_list_init ();
  if(!dbus_connect ())
  {
    main_window_error_message("Unable to connect to the SFLphone server.\nMake sure the daemon is running.");
    return FALSE;
  }
  else 
  {
    dbus_register(getpid(), "Gtk+ Client");
    sflphone_fill_account_list();
    return TRUE;
  }
}

void 
sflphone_hang_up()
{
  call_t * selectedCall = call_get_selected();
  if(selectedCall)
  {
    switch(selectedCall->state)
    {
      case CALL_STATE_CURRENT:
      case CALL_STATE_HOLD:
      case CALL_STATE_DIALING:
      case CALL_STATE_RINGING:
      case CALL_STATE_BUSY:
      case CALL_STATE_FAILURE:
        dbus_hang_up (selectedCall);
        break;
      case CALL_STATE_INCOMING:  
        dbus_refuse (selectedCall);
        break;
      case CALL_STATE_TRANSFERT:  
        dbus_hang_up (selectedCall);
        break;
      default:
        g_warning("Should not happen in sflphone_hang_up()!");
        break;
    }
  }
}


void 
sflphone_pick_up()
{
  call_t * selectedCall = call_get_selected();
  if(selectedCall)
  {
    switch(selectedCall->state)
    {
      case CALL_STATE_DIALING:
        sflphone_place_call (selectedCall);
        break;
      case CALL_STATE_INCOMING:
        dbus_accept (selectedCall);
        break;
      case CALL_STATE_HOLD:
        dbus_unhold (selectedCall);
        break;
      case CALL_STATE_TRANSFERT:
        dbus_transfert (selectedCall);
        break;
      default:
        g_warning("Should not happen in sflphone_pick_up()!");
        break;
    }
  }
}

void 
sflphone_on_hold ()
{
  call_t * selectedCall = call_get_selected();
  if(selectedCall)
  {
    switch(selectedCall->state)
    {
      case CALL_STATE_CURRENT:
        dbus_hold (selectedCall);
        break;
      default:
        g_warning("Should not happen in sflphone_on_hold!");
        break;
    }
  }
}

void 
sflphone_off_hold ()
{
  call_t * selectedCall = call_get_selected();
  if(selectedCall)
  {
    switch(selectedCall->state)
    {
      case CALL_STATE_HOLD:
        dbus_unhold (selectedCall);
        break;
      default:
        g_warning("Should not happen in sflphone_off_hold ()!");
        break;
      }
  }
}


void 
sflphone_fail( call_t * c )
{
  c->state = CALL_STATE_FAILURE;
  update_call_tree(c);
  update_menus();
  screen_set_call(c);
}

void 
sflphone_busy( call_t * c )
{
  c->state = CALL_STATE_BUSY;
  update_call_tree(c);
  update_menus();
  screen_set_call(c);
}

void 
sflphone_current( call_t * c )
{
  c->state = CALL_STATE_CURRENT;
  update_call_tree(c);
  update_menus();
  screen_set_call(c);
}

void 
sflphone_set_transfert()
{
  call_t * c = call_get_selected();
  if(c)
  {
    c->state = CALL_STATE_TRANSFERT;
    c->to = g_strdup("");
    screen_set_call(c);
    update_call_tree(c);
    update_menus();
  }
  toolbar_update_buttons();
}

void 
sflphone_unset_transfert()
{
  call_t * c = call_get_selected();
  if(c)
  {
    c->state = CALL_STATE_CURRENT;
    c->to = g_strdup("");
    screen_set_call(c);
    update_call_tree(c);
    update_menus();
  }
  toolbar_update_buttons();
}
void
sflphone_incoming_call (call_t * c) 
{
  call_list_add ( c );
  status_icon_unminimize();
  update_call_tree_add(c);
  update_menus();
}

void 
sflphone_hung_up (call_t * c )
{
  call_list_remove(c->callID);
  update_call_tree_remove(c);
  update_menus();
  screen_clear();
}

void process_dialing(call_t * c, guint keyval, gchar * key)
{
  switch (keyval)
  {
  case 65293: /* ENTER */
  case 65421: /* ENTER numpad */
    sflphone_place_call(c);
    break;
  case 65307: /* ESCAPE */
    dbus_hang_up(c);
    break;
  case 65288: /* BACKSPACE */
    {  /* Brackets mandatory because of local vars */
      gchar * before = c->to;
      if(strlen(c->to) > 1){
        c->to = g_strndup(c->to, strlen(c->to) -1);
        g_free(before);
        g_print("TO: %s\n", c->to);
      
        if(c->state == CALL_STATE_DIALING)
        {
          g_free(c->from);
          c->from = g_strconcat("\"\" <", c->to, ">", NULL);
        }
        screen_set_call(c);
        update_call_tree(c);
      } 
      else if(strlen(c->to) == 1)
      {
        dbus_hang_up(c);
      }
    }
    break;
  case 65289: /* TAB */
  case 65513: /* ALT */
  case 65507: /* CTRL */
  case 65515: /* SUPER */
  case 65509: /* CAPS */
    break;
  default:
    if (keyval < 255 || (keyval >65453 && keyval < 65466))
    { 
      gchar * before = c->to;
      c->to = g_strconcat(c->to, key, NULL);
      g_free(before);
      g_print("TO: %s\n", c->to);
      
      if(c->state == CALL_STATE_DIALING)
      {
        g_free(c->from);
        c->from = g_strconcat("\"\" <", c->to, ">", NULL);
      }
      screen_set_call(c);
      update_call_tree(c);
    }
    break;
  }
  
}


call_t * sflphone_new_call()
{
  call_t * c = g_new0 (call_t, 1);
  c->state = CALL_STATE_DIALING;
  c->from = g_strconcat("\"\" <>", NULL);
  
  c->callID = g_new0(gchar, 30);
  g_sprintf(c->callID, "%d", rand()); 
  
  c->to = g_strdup("");
  
  call_list_add(c);
  screen_set_call(c);
  update_call_tree_add(c);  
  update_menus();
  
  return c;
}

void 
sflphone_keypad( guint keyval, gchar * key)
{
  call_t * c = call_get_selected();
  if(c)
  {
  
    switch(c->state) 
    {
      case CALL_STATE_DIALING: // Currently dialing => edit number
        process_dialing(c, keyval, key);
        break;
      case CALL_STATE_CURRENT:
        switch (keyval)
        {
        case 65307: /* ESCAPE */
          dbus_hang_up(c);
          break;
        default:  // TODO should this be here?
          dbus_play_dtmf(key);
          if (keyval < 255 || (keyval >65453 && keyval < 65466))
          { 
            gchar * temp = g_strconcat(call_get_number(c), key, NULL);
            gchar * before = c->from;
            c->from = g_strconcat("\"",call_get_name(c) ,"\" <", temp, ">", NULL);
            g_free(before);
            g_free(temp);
            screen_set_call(c);
            update_call_tree(c);
          }
          break;
        }
        break;
      case CALL_STATE_INCOMING:
        switch (keyval)
        {
        case 65293: /* ENTER */
        case 65421: /* ENTER numpad */
          dbus_accept(c);
          break;
        case 65307: /* ESCAPE */
          dbus_refuse(c);
          break;
        }
        break;
      case CALL_STATE_TRANSFERT:
        switch (keyval)
        {
        case 65293: /* ENTER */
        case 65421: /* ENTER numpad */
          dbus_transfert(c);
          break;
        case 65307: /* ESCAPE */
          sflphone_hang_up(c); 
          break;
        default: // When a call is on transfert, typing new numbers will add it to c->to
          process_dialing(c, keyval, key);
          break;
        }
        break;
      case CALL_STATE_HOLD:
        switch (keyval)
        {
        case 65293: /* ENTER */
        case 65421: /* ENTER numpad */
          dbus_unhold(c);
          break;
        case 65307: /* ESCAPE */
          dbus_hang_up(c);
          break;
        default: // When a call is on hold, typing new numbers will create a new call
          process_dialing(sflphone_new_call(), keyval, key);
          break;
        }
        break;
      case CALL_STATE_RINGING:
      case CALL_STATE_BUSY:
      case CALL_STATE_FAILURE:
        switch (keyval)
        {
        case 65307: /* ESCAPE */
          dbus_hang_up(c);
          break;
        }
        break;
      default:
        break;
     } 
  }
  else 
  { // Not in a call, not dialing, create a new call 
    switch (keyval)
    {
    case 65293: /* ENTER */
    case 65421: /* ENTER numpad */
    case 65307: /* ESCAPE */
      break;
    default:
      process_dialing(sflphone_new_call(), keyval, key);
      break;
    }
        
     
  }
} 


void 
sflphone_place_call ( call_t * c )
{
  if(c->state == CALL_STATE_DIALING)
  {
    account_t * a = account_list_get_by_state (ACCOUNT_STATE_REGISTERED);
    if(a)
    {
      c->accountID = a->accountID;
      dbus_place_call(c);
    }
    else
    {
      main_window_error_message("There are no registered accounts to make this call with.");
    }
    
  }
}