uimanager.c

/*
 *  Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010, 2011 Savoir-Faire Linux Inc.
 *  Author: Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com
 *
 *  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 3 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.
 *
 *  Additional permission under GNU GPL version 3 section 7:
 *
 *  If you modify this program, or any covered work, by linking or
 *  combining it with the OpenSSL project's OpenSSL library (or a
 *  modified version of that library), containing parts covered by the
 *  terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
 *  grants you additional permission to convey the resulting work.
 *  Corresponding Source for a non-source form of such a combination
 *  shall include the source code for the parts of OpenSSL used as well
 *  as that of the covered work.
 */

#include <config.h>
#include <preferencesdialog.h>
#include <dbus/dbus.h>
#include <mainwindow.h>
#include <assistant.h>
#include <gtk/gtk.h>
#include <string.h>
#include <glib/gprintf.h>
#include <libgnome/gnome-help.h>

#include <uimanager.h>
#include <statusicon.h>
#include <widget/imwidget.h>
#include <eel-gconf-extensions.h>


#include "uimanager.h"
#include "statusicon.h"

#include "contacts/addrbookfactory.h"
#include "config/addressbook-config.h"

#include "accountlist.h"
#include "config/accountlistconfigdialog.h"

void show_edit_number (callable_obj_t *call);

static GtkWidget *toolbar;

static guint transfertButtonConnId; //The button toggled signal connection ID
static guint recordButtonConnId; //The button toggled signal connection ID

static GtkAction * pickUpAction;
static GtkWidget * pickUpWidget;
static GtkAction * newCallAction;
static GtkWidget * newCallWidget;
static GtkAction * hangUpAction;
static GtkWidget * hangUpWidget;
static GtkWidget * holdMenu;
static GtkWidget * holdToolbar;
static GtkWidget * offHoldToolbar;
static GtkWidget * transferToolbar;
static GtkAction * copyAction;
static GtkAction * pasteAction;
static GtkAction * recordAction;
static GtkWidget * recordWidget;
static GtkAction * voicemailAction;
static GtkWidget * voicemailToolbar;
static GtkWidget * imToolbar;
static GtkAction * imAction;
static GtkWidget * playRecordWidget;
static GtkWidget * stopRecordWidget;

static GtkWidget * editable_num;
static GtkDialog * edit_dialog;

enum {
    CALLTREE_CALLS, CALLTREE_HISTORY, CALLTREE_CONTACTS
};

static gboolean
is_inserted (GtkWidget* button, GtkWidget *current_toolbar)
{
    return (GTK_WIDGET (button)->parent == GTK_WIDGET (current_toolbar));
}

void
update_actions()
{

    DEBUG ("UIManager: Update action");
	
    gtk_action_set_sensitive (GTK_ACTION (newCallAction), TRUE);
    gtk_action_set_sensitive (GTK_ACTION (pickUpAction), FALSE);
    gtk_action_set_sensitive (GTK_ACTION (hangUpAction), FALSE);
    gtk_action_set_sensitive (GTK_ACTION (imAction), FALSE);

    g_object_ref (hangUpWidget);
    g_object_ref (recordWidget);
    g_object_ref (holdToolbar);
    g_object_ref (offHoldToolbar);
    if(abookfactory_is_addressbook_loaded()) {
        g_object_ref (contactButton);
    }
    g_object_ref (historyButton);
    g_object_ref (transferToolbar);
    g_object_ref (voicemailToolbar);
    g_object_ref (imToolbar);

    if (is_inserted (GTK_WIDGET (hangUpWidget), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (hangUpWidget));
    }

    if (is_inserted (GTK_WIDGET (recordWidget), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (recordWidget));
    }

    if (is_inserted (GTK_WIDGET (transferToolbar), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (transferToolbar));
    }

    if (is_inserted (GTK_WIDGET (historyButton), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (historyButton));
    }

    if(abookfactory_is_addressbook_loaded()) {
        if (is_inserted (GTK_WIDGET (contactButton), GTK_WIDGET (toolbar))) {
            gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (contactButton));
        }
    }

    if (is_inserted (GTK_WIDGET (voicemailToolbar), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar),
                              GTK_WIDGET (voicemailToolbar));
    }

    if (is_inserted (GTK_WIDGET (imToolbar), GTK_WIDGET (toolbar))) {
        gtk_container_remove (GTK_CONTAINER (toolbar),
                              GTK_WIDGET (imToolbar));
    }
    
    gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), FALSE);
    gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), FALSE);
    gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), FALSE);
    gtk_action_set_sensitive (GTK_ACTION (recordAction), FALSE);
    gtk_widget_set_sensitive (GTK_WIDGET (recordWidget), FALSE);
    gtk_action_set_sensitive (GTK_ACTION (copyAction), FALSE);

    if(abookfactory_is_addressbook_loaded()) { 
        gtk_widget_set_sensitive (GTK_WIDGET (contactButton), FALSE);
    }
    gtk_widget_set_sensitive (GTK_WIDGET (historyButton), FALSE);
    if(abookfactory_is_addressbook_loaded()) {
        gtk_widget_set_tooltip_text (GTK_WIDGET (contactButton),_("No address book selected"));
    }

    if (is_inserted (GTK_WIDGET (holdToolbar), GTK_WIDGET (toolbar)))
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (holdToolbar));

    if (is_inserted (GTK_WIDGET (offHoldToolbar), GTK_WIDGET (toolbar)))
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (offHoldToolbar));

    if (is_inserted (GTK_WIDGET (newCallWidget), GTK_WIDGET (toolbar)))
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));

    if (is_inserted (GTK_WIDGET (pickUpWidget), GTK_WIDGET (toolbar)))
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (pickUpWidget));

    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (newCallWidget), 0);

    if(is_inserted(GTK_WIDGET (playRecordWidget), GTK_WIDGET(toolbar)))
	gtk_container_remove(GTK_CONTAINER(toolbar), GTK_WIDGET(playRecordWidget));
    if(is_inserted(GTK_WIDGET (stopRecordWidget), GTK_WIDGET(toolbar)))
	gtk_container_remove(GTK_CONTAINER(toolbar), GTK_WIDGET(stopRecordWidget));

    if (eel_gconf_get_integer (HISTORY_ENABLED)) {
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (historyButton), -1);
        gtk_widget_set_sensitive (GTK_WIDGET (historyButton), TRUE);
    }

    // If addressbook support has been enabled and all addressbooks are loaded, display the icon
   
    if(abookfactory_is_addressbook_loaded()) {
        AddrBookFactory *bookFactory = abookfactory_get_factory();
        AddressBook_Config *addressbook_config;
	addressbook_config_load_parameters(&addressbook_config);
 
        if (addressbook_config->enable && bookFactory->addrbook->is_ready()) {
            gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (contactButton), -1);

            // Make the icon clickable only if at least one address book is active
            if (bookFactory->addrbook->is_active()) {
                gtk_widget_set_sensitive (GTK_WIDGET (contactButton), TRUE);
                gtk_widget_set_tooltip_text (GTK_WIDGET (contactButton),_ ("Address book"));
            }
        }
    }

    callable_obj_t * selectedCall = calltab_get_selected_call (active_calltree);
    conference_obj_t * selectedConf = calltab_get_selected_conf (active_calltree);

    gboolean instant_messaging_enabled = TRUE;
    
    if (eel_gconf_key_exists (INSTANT_MESSAGING_ENABLED)) {
        instant_messaging_enabled = eel_gconf_get_integer (INSTANT_MESSAGING_ENABLED);
    }

    if (selectedCall) {

        DEBUG("UIManager: Update actions for call %s", selectedCall->_callID); 

        // update icon in systray
        show_status_hangup_icon();

        gtk_action_set_sensitive (GTK_ACTION (copyAction), TRUE);

        switch (selectedCall->_state) {
            case CALL_STATE_INCOMING:
		DEBUG("UIManager: Call State Incoming");
                // Make the button toolbar clickable
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                // Replace the dial button with the hangup button
                g_object_ref (newCallWidget);
                gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget),
                                    0);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
                                    1);
                break;
            case CALL_STATE_HOLD:
		DEBUG("UIManager: Call State Hold");
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (newCallWidget), TRUE);

                // Replace the hold button with the off-hold button
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (offHoldToolbar), 2);

                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 3);
                }

                break;
            case CALL_STATE_RINGING:
		DEBUG("UIManager: Call State Ringing");
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
                                    1);
                break;
            case CALL_STATE_DIALING:
                DEBUG("UIManager: Call State Dialing");
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);

                if (active_calltree == current_calls)
                    gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);

                g_object_ref (newCallWidget);
                gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget), 0);

                if (active_calltree == current_calls)
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                else if (active_calltree == history) {
                    if (selectedCall->_recordfile && (g_strcmp0(selectedCall->_recordfile, "") != 0)) {
                        if (selectedCall->_record_is_playing)
                            gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM(stopRecordWidget), 3);
                        else
                            gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM(playRecordWidget), 3);
                    }
                }
                break;
            case CALL_STATE_CURRENT:
                DEBUG ("UIManager: Call State Current");
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 3);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 4);
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), FALSE);
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
                g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
                g_signal_handler_unblock (GTK_OBJECT (recordWidget), recordButtonConnId);

                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 5);
                }

                break;

            case CALL_STATE_RECORD:
                DEBUG ("UIManager: Call State Record");
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 3);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 4);
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), FALSE);
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
                g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), TRUE);
                g_signal_handler_unblock (GTK_OBJECT (recordWidget), recordButtonConnId);

                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 5);
                }

                break;
            case CALL_STATE_BUSY:
            case CALL_STATE_FAILURE:
		DEBUG("UIManager: Call State Busy/Failure"); 
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                break;
            case CALL_STATE_TRANSFERT:
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 2);
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), TRUE);
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
                break;
            default:
                ERROR ("UIMAnager: Error: Unknown state in action update!");
                break;
        }
    } else if (selectedConf) {

        DEBUG("UIManager: Update actions for conference");

        // update icon in systray
        show_status_hangup_icon();


        switch (selectedConf->_state) {

            case CONFERENCE_STATE_ACTIVE_ATACHED:
            case CONFERENCE_STATE_ACTIVE_DETACHED:
		DEBUG("UIManager: Conference State Active");
		if(active_calltree == current_calls) {
                    gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                    gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
                    gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
                    if (instant_messaging_enabled) {
                        gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
                    }
		}
		else if(active_calltree == history) {
		    if(selectedConf->_recordfile && (g_strcmp0(selectedConf->_recordfile, "") != 0)) {
                        if(selectedConf->_record_is_playing)
                            gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM(stopRecordWidget), 3);
                        else
                            gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM(playRecordWidget), 3);
                    }

		}
                break;
            case CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD:
            case CONFERENCE_STATE_ACTIVE_DETACHED_RECORD:
		DEBUG("UIManager: Conference State Record");
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
                }
                break;
            case CONFERENCE_STATE_HOLD:
            case CONFERENCE_STATE_HOLD_RECORD:
		DEBUG("UIManager: Conference State Hold");
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
                gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), TRUE);
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (offHoldToolbar), 2);
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
                }
                break;
            default:
                WARN ("UIManager: Error: Should not happen in action update!");
                break;
        }
    }

    else {

        // update icon in systray
        hide_status_hangup_icon();

        if (account_list_get_size() > 0 && current_account_has_mailbox()) {
            gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
                                GTK_TOOL_ITEM (voicemailToolbar), -2);
            update_voicemail_status();
        }
    }
}

void
update_voicemail_status (void)
{
    gchar *messages = "";
    messages = g_markup_printf_escaped (_ ("Voicemail (%i)"),
                                        current_account_get_message_number());
    (current_account_has_new_message()) ? gtk_tool_button_set_icon_name (
        GTK_TOOL_BUTTON (voicemailToolbar), "mail-message-new")
    : gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (voicemailToolbar),
                                     "mail-read");
    gtk_tool_button_set_label (GTK_TOOL_BUTTON (voicemailToolbar), messages);
    g_free (messages);
}

static void
volume_bar_cb (GtkToggleAction *togglemenuitem, gpointer user_data UNUSED)
{
    gboolean toggled = gtk_toggle_action_get_active (togglemenuitem);

    if (toggled == SHOW_VOLUME)
        return;

    main_window_volume_controls (toggled);

    if (toggled || SHOW_VOLUME)
        eel_gconf_set_integer (SHOW_VOLUME_CONTROLS, toggled);
}

static void
dialpad_bar_cb (GtkToggleAction *togglemenuitem, gpointer user_data UNUSED)
{
    gboolean toggled = gtk_toggle_action_get_active (togglemenuitem);
    gboolean conf_dialpad = eel_gconf_get_boolean (CONF_SHOW_DIALPAD);

    if (toggled == conf_dialpad)
        return;

    main_window_dialpad (toggled);

    if (toggled || conf_dialpad)
        eel_gconf_set_boolean (CONF_SHOW_DIALPAD, toggled); //dbus_set_dialpad (toggled);

}

static void
help_contents_cb (GtkAction *action UNUSED)
{
    GError *error = NULL;

    gnome_help_display ("sflphone.xml", NULL, &error);

    if (error != NULL) {
        g_warning ("%s", error->message);
        g_error_free (error);
    }
}

static void
help_about (void * foo UNUSED)
{
    gchar
    *authors[] = {
        "Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com>",
        "Jean-Philippe Barrette-LaPierre",
        "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
        "Julien Bonjean <julien.bonjean@savoirfairelinux.com>",
        "Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>",
        "Laurielle Lea",
        "Yun Liu <yun.liu@savoirfairelinux.com>",
        "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>",
        "Yan Morin <yan.morin@savoirfairelinux.com>",
        "Jérôme Oufella <jerome.oufella@savoirfairelinux.com>",
        "Julien Plissonneau Duquene <julien.plissonneau.duquene@savoirfairelinux.com>",
        "Alexandre Savard <alexandre.savard@savoirfairelinux.com>", NULL
    };
    gchar *artists[] = { "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
                         "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>", NULL
                       };

    gtk_show_about_dialog (GTK_WINDOW (get_main_window()), "artists", artists,
                           "authors", authors, "comments",
                           _ ("SFLphone is a VoIP client compatible with SIP and IAX2 protocols."),
                           "copyright", "Copyright © 2004-2011 Savoir-faire Linux Inc.", "name",
                           PACKAGE, "title", _ ("About SFLphone"), "version", VERSION, "website",
                           "http://www.sflphone.org", NULL);

}

/* ----------------------------------------------------------------- */

static void
call_new_call (void * foo UNUSED)
{
    DEBUG ("UIManager: New call button pressed");

    sflphone_new_call();
}

static void
call_quit (void * foo UNUSED)
{
    sflphone_quit();
}

static void
call_minimize (void * foo UNUSED)
{

    if (eel_gconf_get_integer (SHOW_STATUSICON)) {
        gtk_widget_hide (GTK_WIDGET (get_main_window()));
        set_minimized (TRUE);
    } else {
        sflphone_quit ();
    }
}

static void
switch_account (GtkWidget* item, gpointer data UNUSED)
{
    account_t* acc = g_object_get_data (G_OBJECT (item), "account");
    DEBUG ("%s" , acc->accountID);
    account_list_set_current (acc);
    status_bar_display_account();
}

static void
call_hold (void* foo UNUSED)
{
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
    conference_obj_t * selectedConf = calltab_get_selected_conf(current_calls);

    DEBUG ("UIManager: Hold button pressed");

    if (selectedCall) {
        if (selectedCall->_state == CALL_STATE_HOLD) {
            sflphone_off_hold();
        } else {
            sflphone_on_hold();
        }
    } else if (selectedConf) {

        switch (selectedConf->_state) {

            case CONFERENCE_STATE_HOLD:
                selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
                sflphone_conference_off_hold (selectedConf);
                break;
            case CONFERENCE_STATE_HOLD_RECORD:
                selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD;
                sflphone_conference_off_hold (selectedConf);
                break;

            case CONFERENCE_STATE_ACTIVE_ATACHED:
            case CONFERENCE_STATE_ACTIVE_DETACHED:
                selectedConf->_state = CONFERENCE_STATE_HOLD;
                sflphone_conference_on_hold (selectedConf);
                break;
            case CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD:
            case CONFERENCE_STATE_ACTIVE_DETACHED_RECORD:
              selectedConf->_state = CONFERENCE_STATE_HOLD_RECORD;
              sflphone_conference_on_hold (selectedConf);
              break;
            default:
                break;
        }

    }
}

static void
call_im (void* foo UNUSED)
{
    callable_obj_t *selectedCall = calltab_get_selected_call (current_calls);
    conference_obj_t *selectedConf = calltab_get_selected_conf(current_calls);

    if (calltab_get_selected_type (current_calls) == A_CALL) {

        if (selectedCall) {
            im_widget_display ( (IMWidget **) (&selectedCall->_im_widget), NULL, selectedCall->_callID, NULL);
        } else {
            WARN ("Sorry. Instant messaging is not allowed outside a call\n");
        }
    } else {
        if (selectedConf) {
            im_widget_display ( (IMWidget **) (&selectedConf->_im_widget), NULL, selectedConf->_confID, NULL);
        } else {
            WARN ("Sorry. Instant messaging is not allowed outside a call\n");
        }
    }
}

static void
conference_hold (void* foo UNUSED)
{
    conference_obj_t * selectedConf = calltab_get_selected_conf(current_calls);

    DEBUG ("UIManager: Hold button pressed for conference");

    if(selectedConf == NULL) {
        ERROR("UIManager: No conference selected");
	return;
    }

    switch (selectedConf->_state) {
        case CONFERENCE_STATE_HOLD:
            selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
            sflphone_conference_off_hold (selectedConf);
            break;
        case CONFERENCE_STATE_HOLD_RECORD:
            selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD;
            sflphone_conference_off_hold (selectedConf);
            break;
        case CONFERENCE_STATE_ACTIVE_ATACHED:
        case CONFERENCE_STATE_ACTIVE_DETACHED:
            selectedConf->_state = CONFERENCE_STATE_HOLD;
            sflphone_conference_on_hold (selectedConf);
            break;
        case CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD:
        case CONFERENCE_STATE_ACTIVE_DETACHED_RECORD:
            selectedConf->_state = CONFERENCE_STATE_HOLD_RECORD;
            sflphone_conference_on_hold(selectedConf);
        default:
            break;
    }
}

static void
call_pick_up (void * foo UNUSED)
{
    callable_obj_t * selectedCall;
    callable_obj_t* new_call;
    
    DEBUG ("UIManager: Pick up");

    if (calllist_get_size (current_calls) > 0) {
        sflphone_pick_up();
    }

    else if (calllist_get_size (active_calltree) > 0) {
	selectedCall = calltab_get_selected_call(active_calltree);

        if (selectedCall) {
            new_call = create_new_call (CALL, CALL_STATE_DIALING, "", "", "",
                             selectedCall->_peer_number);

            calllist_add_call (current_calls, new_call);
            calltree_add_call (current_calls, new_call, NULL);
            sflphone_place_call (new_call);
            calltree_display (current_calls);
        } else {
            sflphone_new_call();
            calltree_display (current_calls);
        }
    } else {
        sflphone_new_call();
        calltree_display (current_calls);
    }
}

static void
call_hang_up (void)
{
    DEBUG ("UIManager: Hang up button pressed (call)");
    /*
     * [#3020]	Restore the record toggle button
     *			We set it to FALSE, as when we hang up a call, the recording is stopped.
     */

    sflphone_hang_up();

}

static void
conference_hang_up (void)
{
    DEBUG ("UIManager: Hang up button pressed (conference)");

    sflphone_conference_hang_up();
}

static void
call_record (void)
{
    DEBUG ("UIManager: Record button pressed");

    sflphone_rec_call();
}

static void
start_playback_record_cb(void)
{
    gboolean result;

    DEBUG("UIManager: Start playback button pressed");

    callable_obj_t *selectedCall = calltab_get_selected_call (history);
    conference_obj_t *selectedConf = calltab_get_selected_conf (history);

    if((selectedCall == NULL) && (selectedConf == NULL)) {
        ERROR("UIManager: Error: No selected object in playback record callback");
	return;
    }

    if(selectedCall && selectedConf) {
	ERROR("UIManager: Error: Two selected object in playback record callback");
	return;
    }

    if(selectedCall) {
	DEBUG("UIManager: Start selected call file playback %s", selectedCall->_recordfile);
        result = dbus_start_recorded_file_playback(selectedCall->_recordfile);
	selectedCall->_record_is_playing = result;
    }
    else if(selectedConf) {
	DEBUG("UIMAnager: Start selected conf file playback %s", selectedConf->_recordfile);
	result = dbus_start_recorded_file_playback(selectedConf->_recordfile);
	selectedConf->_record_is_playing = result;
    } 

    update_actions();
}

static void
stop_playback_record_cb(void)
{
    DEBUG("UIManager: Stop playback button pressed");

    callable_obj_t *selectedCall = calltab_get_selected_call (history);
    conference_obj_t *selectedConf = calltab_get_selected_conf(history);

    if(selectedCall && selectedConf) {
        ERROR("UIManager: Error: Two selected object in history treeview");
	return;
    }

    if((selectedCall == NULL) && (selectedConf == NULL)) {
        ERROR("UIManager: Error: No selected object in history treeview");
	return;
    }

    if(selectedCall) {
        if(selectedCall->_recordfile == NULL) {
            ERROR("UIManager: Error: Record file is NULL");
	    return;
        }
	dbus_stop_recorded_file_playback(selectedCall->_recordfile);
	DEBUG("UIManager: Stop selected call file playback %s", selectedCall->_recordfile);
	selectedCall->_record_is_playing = FALSE;
    } 
    else if(selectedConf) {
        if(selectedConf->_recordfile == NULL) {
            ERROR("UIManager: Error: Record file is NULL");
	    return;
	}
        dbus_stop_recorded_file_playback(selectedConf->_recordfile);
	DEBUG("UIMAnager: Start selected call file playback: %s", selectedConf->_recordfile);
	selectedConf->_record_is_playing = FALSE;
    }

    update_actions();
}

static void
call_configuration_assistant (void * foo UNUSED)
{
#if GTK_CHECK_VERSION(2,10,0)
    build_wizard();
#endif
}

static void
remove_from_history (void * foo UNUSED)
{
    callable_obj_t* call = calltab_get_selected_call (history);

    DEBUG ("UIManager: Remove the call from the history");

    if(call == NULL) {
	ERROR("UIManager: Error: Call is NULL");
    	return;
    }

    calllist_remove_from_history (call);
}

static void
call_back (void * foo UNUSED)
{
    callable_obj_t *selected_call, *new_call;

    selected_call = calltab_get_selected_call (active_calltree);

    DEBUG("UIManager: Call back");

    if(selected_call == NULL) {
	ERROR("UIManager: Error: No selected call");
	return;
    }

    new_call = create_new_call (CALL, CALL_STATE_DIALING, "", "",
                         selected_call->_peer_name, selected_call->_peer_number);

    calllist_add_call (current_calls, new_call);
    calltree_add_call (current_calls, new_call, NULL);
    sflphone_place_call (new_call);
    calltree_display (current_calls);
}

static void
edit_preferences (void * foo UNUSED)
{
    show_preferences_dialog();
}

static void
edit_accounts (void * foo UNUSED)
{
    show_account_list_config_dialog();
}

// The menu Edit/Copy should copy the current selected call's number
static void
edit_copy (void * foo UNUSED)
{
    GtkClipboard* clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
    gchar * no = NULL;

    DEBUG("UIManager: Edit/Copy");

    if(selectedCall == NULL) {
        ERROR("UIManager: Error: No selected call", selectedCall);
    	return;
    }

    switch (selectedCall->_state) {
        case CALL_STATE_TRANSFERT:
        case CALL_STATE_DIALING:
        case CALL_STATE_RINGING:
            no = selectedCall->_peer_number;
            break;
        case CALL_STATE_CURRENT:
        case CALL_STATE_RECORD:
        case CALL_STATE_HOLD:
        case CALL_STATE_BUSY:
        case CALL_STATE_FAILURE:
        case CALL_STATE_INCOMING:
        default:
            no = selectedCall->_peer_number;
            break;
    }

    DEBUG ("UIManager: Clipboard number: %s\n", no);
    gtk_clipboard_set_text (clip, no, strlen (no));

}

// The menu Edit/Paste should paste the clipboard into the current selected call
static void
edit_paste (void * foo UNUSED)
{

    GtkClipboard* clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
    gchar * no = gtk_clipboard_wait_for_text (clip);

    if (no && selectedCall) {
        switch (selectedCall->_state) {
            case CALL_STATE_TRANSFERT:
            case CALL_STATE_DIALING:
                // Add the text to the number
            {
                gchar * before;
                before = selectedCall->_peer_number;
                DEBUG ("TO: %s\n", before);
                selectedCall->_peer_number = g_strconcat (before, no, NULL);

                if (selectedCall->_state == CALL_STATE_DIALING) {
                    selectedCall->_peer_info = g_strconcat ("\"\" <",
                                                            selectedCall->_peer_number, ">", NULL);
                }

                calltree_update_call (current_calls, selectedCall, NULL);
            }
            break;
            case CALL_STATE_RINGING:
            case CALL_STATE_INCOMING:
            case CALL_STATE_BUSY:
            case CALL_STATE_FAILURE:
            case CALL_STATE_HOLD: { // Create a new call to hold the new text
                selectedCall = sflphone_new_call();

                selectedCall->_peer_number = g_strconcat (selectedCall->_peer_number,
                                             no, NULL);
                DEBUG ("TO: %s", selectedCall->_peer_number);

                selectedCall->_peer_info = g_strconcat ("\"\" <",
                                                        selectedCall->_peer_number, ">", NULL);

                calltree_update_call (current_calls, selectedCall, NULL);
            }
            break;
            case CALL_STATE_CURRENT:
            case CALL_STATE_RECORD:
            default: {
                unsigned int i;

                for (i = 0; i < strlen (no); i++) {
                    gchar * oneNo = g_strndup (&no[i], 1);
                    DEBUG ("<%s>", oneNo);
                    dbus_play_dtmf (oneNo);

                    gchar * temp = g_strconcat (selectedCall->_peer_number, oneNo,
                                                NULL);
                    selectedCall->_peer_info = get_peer_info (temp,
                                               selectedCall->_peer_name);
                    g_free(temp);
                    calltree_update_call (current_calls, selectedCall, NULL);

                }
            }
            break;
        }

    } else { // There is no current call, create one
        selectedCall = sflphone_new_call();

        gchar * before = selectedCall->_peer_number;
        selectedCall->_peer_number = g_strconcat (selectedCall->_peer_number, no,
                                     NULL);
        g_free (before);
        DEBUG ("UIManager: TO: %s", selectedCall->_peer_number);

        g_free (selectedCall->_peer_info);
        selectedCall->_peer_info = g_strconcat ("\"\" <",
                                                selectedCall->_peer_number, ">", NULL);
        calltree_update_call (current_calls, selectedCall, NULL);
    }

}

static void
clear_history (void)
{
    if(conferencelist_get_size(history) != 0) {
	conferencelist_clean_history();
    }

    if (calllist_get_size (history) != 0) {
        calllist_clean_history();
    }
}

/**
 * Transfer the line
 */
static void
call_transfer_cb()
{
    gboolean active = gtk_toggle_tool_button_get_active (
                          GTK_TOGGLE_TOOL_BUTTON (transferToolbar));
    active ? sflphone_set_transfert() : sflphone_unset_transfert();