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 "logger.h"
#include "dbus/dbus.h"
#include "mainwindow.h"
#include "assistant.h"
#include <gtk/gtk.h>
#include <string.h>
#include <glib/gprintf.h>

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

#include "config/audioconf.h"
#include "unused.h"
#include "uimanager.h"
#include "statusicon.h"

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

#include "eel-gconf-extensions.h"

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

#include <sys/stat.h>

#include <sliders.h>

void show_edit_number(callable_obj_t *call);

static GtkWidget *toolbar_;

static guint transferButtonConnId_; //The button toggled signal connection ID
static guint recordButtonConnId_; //The button toggled signal connection ID
static guint muteCallButtonId_; //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 GtkAction * muteAction_;
static GtkWidget * recordWidget_;
static GtkWidget * muteWidget_;
static GtkAction * voicemailAction_;
static GtkWidget * voicemailToolbar_;
static GtkWidget * imToolbar_;
static GtkAction * imAction_;
static GtkWidget * playRecordWidget_;
static GtkWidget * stopRecordWidget_;

static GtkWidget * editable_num_;
static GtkWidget * edit_dialog_;

enum {
    CALLTREE_CALLS, CALLTREE_HISTORY, CALLTREE_CONTACTS
};

static void
remove_from_toolbar(GtkWidget *widget)
{
    /* We must ensure that a widget is a child of a container
     * before removing it. */
    if (gtk_widget_get_parent(widget) == toolbar_)
        gtk_container_remove(GTK_CONTAINER(toolbar_), widget);
}

static bool
is_non_empty(const char *str)
{
    return str && strlen(str) > 0;
}

/* Inserts an item in a toolbar at a given position, making sure that the index
 * is valid, that it does not exceed the number of elements */
static void add_to_toolbar(GtkWidget *toolbar, GtkWidget *item, int pos)
{
    g_assert(gtk_toolbar_get_n_items(GTK_TOOLBAR(toolbar)) >= pos);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), pos);
}

static void
call_mute(void)
{
    DEBUG("UIManager: Mute call button pressed");
    sflphone_mute_call();
}

void
update_actions()
{
    int pos = 0;

    gtk_action_set_sensitive(newCallAction_, TRUE);
    gtk_action_set_sensitive(pickUpAction_, FALSE);
    gtk_action_set_sensitive(hangUpAction_, FALSE);
    gtk_action_set_sensitive(imAction_, FALSE);

    g_object_ref(hangUpWidget_);
    g_object_ref(recordWidget_);
    g_object_ref(muteWidget_);
    g_object_ref(holdToolbar_);
    g_object_ref(offHoldToolbar_);

    if (addrbook)
        g_object_ref(contactButton_);

    g_object_ref(historyButton_);
    g_object_ref(transferToolbar_);
    g_object_ref(voicemailToolbar_);
    g_object_ref(imToolbar_);

    remove_from_toolbar(hangUpWidget_);
    remove_from_toolbar(recordWidget_);
    remove_from_toolbar(muteWidget_);
    remove_from_toolbar(transferToolbar_);
    remove_from_toolbar(historyButton_);

    if (addrbook)
        remove_from_toolbar(contactButton_);

    remove_from_toolbar(voicemailToolbar_);
    remove_from_toolbar(imToolbar_);

    gtk_widget_set_sensitive(holdMenu_, FALSE);
    gtk_widget_set_sensitive(holdToolbar_, FALSE);
    gtk_widget_set_sensitive(offHoldToolbar_, FALSE);
    gtk_action_set_sensitive(recordAction_, FALSE);
    gtk_action_set_sensitive(muteAction_, FALSE);
    gtk_widget_set_sensitive(recordWidget_, FALSE);
    gtk_widget_set_sensitive(muteWidget_, FALSE);
    gtk_action_set_sensitive(copyAction_, FALSE);

    if (addrbook)
        gtk_widget_set_sensitive(contactButton_, FALSE);

    gtk_widget_set_sensitive(historyButton_, FALSE);

    if (addrbook)
        gtk_widget_set_tooltip_text(contactButton_, _("No address book selected"));

    remove_from_toolbar(holdToolbar_);
    remove_from_toolbar(offHoldToolbar_);
    remove_from_toolbar(newCallWidget_);
    remove_from_toolbar(pickUpWidget_);

    add_to_toolbar(toolbar_, newCallWidget_, 0);

    remove_from_toolbar(playRecordWidget_);
    remove_from_toolbar(stopRecordWidget_);

    if (eel_gconf_get_integer(HISTORY_ENABLED)) {
        add_to_toolbar(toolbar_, historyButton_, -1);
        gtk_widget_set_sensitive(historyButton_, TRUE);
    }

    GtkToolItem *separator = gtk_separator_tool_item_new();
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar_), separator, -1);
    // add mute button
    add_to_toolbar(toolbar_, muteWidget_, -1);
    gtk_action_set_sensitive(muteAction_, TRUE);

    // If addressbook support has been enabled and all addressbooks are loaded, display the icon
    if (addrbook && addrbook->is_ready() && addressbook_config_load_parameters()->enable) {
        add_to_toolbar(toolbar_, contactButton_, -1);

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

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

    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(copyAction_, TRUE);

        switch (selectedCall->_state) {
            case CALL_STATE_INCOMING:
                {
                    DEBUG("UIManager: Call State Incoming");
                    // Make the button toolbar clickable
                    gtk_action_set_sensitive(pickUpAction_, TRUE);
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    // Replace the dial button with the hangup button
                    g_object_ref(newCallWidget_);
                    remove_from_toolbar(newCallWidget_);
                    pos = 0;
                    add_to_toolbar(toolbar_, pickUpWidget_, pos++);
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    break;
                }
            case CALL_STATE_HOLD:
                {
                    DEBUG("UIManager: Call State Hold");
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    gtk_widget_set_sensitive(holdMenu_, TRUE);
                    gtk_widget_set_sensitive(offHoldToolbar_, TRUE);
                    gtk_widget_set_sensitive(newCallWidget_, TRUE);

                    // Replace the hold button with the off-hold button
                    pos = 1;
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    add_to_toolbar(toolbar_, offHoldToolbar_, pos++);

                    if (instant_messaging_enabled) {
                        gtk_action_set_sensitive(imAction_, TRUE);
                        add_to_toolbar(toolbar_, imToolbar_, pos++);
                    }

                    break;
                }
            case CALL_STATE_RINGING:
                {
                    DEBUG("UIManager: Call State Ringing");
                    gtk_action_set_sensitive(pickUpAction_, TRUE);
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    pos = 1;
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    break;
                }
            case CALL_STATE_DIALING:
                {
                    DEBUG("UIManager: Call State Dialing");
                    gtk_action_set_sensitive(pickUpAction_, TRUE);

                    if (active_calltree_tab == current_calls_tab)
                        gtk_action_set_sensitive(hangUpAction_, TRUE);

                    g_object_ref(newCallWidget_);
                    remove_from_toolbar(newCallWidget_);
                    pos = 0;
                    add_to_toolbar(toolbar_, pickUpWidget_, pos++);

                    if (active_calltree_tab == current_calls_tab)
                        add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    else if (active_calltree_tab == history_tab) {
                        if (is_non_empty(selectedCall->_recordfile)) {
                            if (selectedCall->_record_is_playing)
                                add_to_toolbar(toolbar_, stopRecordWidget_, pos++);
                            else
                                add_to_toolbar(toolbar_, playRecordWidget_, pos++);
                        }
                    }
                    break;
                }
            case CALL_STATE_CURRENT:
                {
                    DEBUG("UIManager: Call State Current");
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    pos = 1;
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    gtk_widget_set_sensitive(holdMenu_, TRUE);
                    gtk_widget_set_sensitive(holdToolbar_, TRUE);
                    gtk_widget_set_sensitive(transferToolbar_, TRUE);
                    gtk_action_set_sensitive(recordAction_, TRUE);
                    add_to_toolbar(toolbar_, holdToolbar_, pos++);
                    add_to_toolbar(toolbar_, transferToolbar_, pos++);
                    add_to_toolbar(toolbar_, recordWidget_, pos++);
                    g_signal_handler_block(transferToolbar_, transferButtonConnId_);
                    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(transferToolbar_), FALSE);
                    g_signal_handler_unblock(transferToolbar_, transferButtonConnId_);
                    g_signal_handler_block(recordWidget_, recordButtonConnId_);
                    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(recordWidget_), FALSE);
                    g_signal_handler_unblock(recordWidget_, recordButtonConnId_);

                    if (instant_messaging_enabled) {
                        gtk_action_set_sensitive(imAction_, TRUE);
                        add_to_toolbar(toolbar_, imToolbar_, pos++);
                    }

                    break;
                }

            case CALL_STATE_RECORD:
                {
                    DEBUG("UIManager: Call State Record");
                    pos = 1;
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    gtk_widget_set_sensitive(holdMenu_, TRUE);
                    gtk_widget_set_sensitive(holdToolbar_, TRUE);
                    gtk_widget_set_sensitive(transferToolbar_, TRUE);
                    gtk_action_set_sensitive(recordAction_, TRUE);
                    add_to_toolbar(toolbar_, holdToolbar_, pos++);
                    add_to_toolbar(toolbar_, transferToolbar_, pos++);
                    add_to_toolbar(toolbar_, recordWidget_, pos++);
                    g_signal_handler_block(transferToolbar_, transferButtonConnId_);
                    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(transferToolbar_), FALSE);
                    g_signal_handler_unblock(transferToolbar_, transferButtonConnId_);
                    g_signal_handler_block(recordWidget_, recordButtonConnId_);
                    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(recordWidget_), TRUE);
                    g_signal_handler_unblock(recordWidget_, recordButtonConnId_);

                    if (instant_messaging_enabled) {
                        gtk_action_set_sensitive(imAction_, TRUE);
                        add_to_toolbar(toolbar_, imToolbar_, pos++);
                    }

                    break;
                }
            case CALL_STATE_BUSY:
            case CALL_STATE_FAILURE:
                {
                    pos = 1;
                    DEBUG("UIManager: Call State Busy/Failure");
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    break;
                }
            case CALL_STATE_TRANSFER:
                {
                    pos = 1;
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    add_to_toolbar(toolbar_, transferToolbar_, pos++);
                    g_signal_handler_block(transferToolbar_, transferButtonConnId_);
                    gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(transferToolbar_), TRUE);
                    g_signal_handler_unblock(transferToolbar_, transferButtonConnId_);
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    gtk_widget_set_sensitive(holdMenu_, TRUE);
                    gtk_widget_set_sensitive(holdToolbar_, TRUE);
                    gtk_widget_set_sensitive(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_ATTACHED:
            case CONFERENCE_STATE_ACTIVE_DETACHED:
                DEBUG("UIManager: Conference State Active");

                if (active_calltree_tab == current_calls_tab) {
                    gtk_action_set_sensitive(hangUpAction_, TRUE);
                    gtk_widget_set_sensitive(holdToolbar_, TRUE);
                    gtk_action_set_sensitive(recordAction_, TRUE);
                    pos = 1;
                    add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                    add_to_toolbar(toolbar_, holdToolbar_, pos++);
                    add_to_toolbar(toolbar_, recordWidget_, pos++);

                    if (instant_messaging_enabled) {
                        gtk_action_set_sensitive(imAction_, TRUE);
                        add_to_toolbar(toolbar_, imToolbar_, pos);
                    }
                } else if (active_calltree_tab == history_tab) {
                    if (is_non_empty(selectedConf->_recordfile)) {
                        pos = 2;
                        if (selectedConf->_record_is_playing)
                            add_to_toolbar(toolbar_, stopRecordWidget_, pos);
                        else
                            add_to_toolbar(toolbar_, playRecordWidget_, pos);
                    }
                }

                break;
            case CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD:
            case CONFERENCE_STATE_ACTIVE_DETACHED_RECORD: {
                pos = 1;
                DEBUG("UIManager: Conference State Record");
                gtk_action_set_sensitive(hangUpAction_, TRUE);
                gtk_widget_set_sensitive(holdToolbar_, TRUE);
                gtk_action_set_sensitive(recordAction_, TRUE);
                add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                add_to_toolbar(toolbar_, holdToolbar_, pos++);
                add_to_toolbar(toolbar_, recordWidget_, pos++);

                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive(imAction_, TRUE);
                    add_to_toolbar(toolbar_, imToolbar_, pos);
                }

                break;
            }
            case CONFERENCE_STATE_HOLD:
            case CONFERENCE_STATE_HOLD_RECORD: {
                DEBUG("UIManager: Conference State Hold");
                pos = 1;
                gtk_action_set_sensitive(hangUpAction_, TRUE);
                gtk_widget_set_sensitive(offHoldToolbar_, TRUE);
                gtk_action_set_sensitive(recordAction_, TRUE);
                add_to_toolbar(toolbar_, hangUpWidget_, pos++);
                add_to_toolbar(toolbar_, offHoldToolbar_, pos++);
                add_to_toolbar(toolbar_, recordWidget_, pos++);

                if (instant_messaging_enabled) {
                    gtk_action_set_sensitive(imAction_, TRUE);
                    add_to_toolbar(toolbar_, imToolbar_, pos);
                }

                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()) {
            add_to_toolbar(toolbar_, voicemailToolbar_, -1);
            update_voicemail_status();
        }
    }
}

void
update_voicemail_status()
{
    gchar *messages = g_markup_printf_escaped(_("Voicemail(%i)"),
                      current_account_get_message_number());

    if (current_account_has_new_message())
        gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(voicemailToolbar_),
                                      "mail-message-new");
    else
        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);
}

static void
help_contents_cb(GtkAction *action UNUSED)
{
    GError *error = NULL;
    gtk_show_uri(NULL, "ghelp:sflphone", GDK_CURRENT_TIME, &error);
    if (error != NULL) {
        g_warning("%s", error->message);
        g_error_free(error);
    }
}

static void
help_about(void * foo UNUSED)
{
    static const 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
    };
    static const 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(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_tab);
    conference_obj_t * selectedConf = calltab_get_selected_conf(current_calls_tab);

    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_ATTACHED;
                dbus_unhold_conference(selectedConf);
                break;
            case CONFERENCE_STATE_HOLD_RECORD:
                selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD;
                dbus_unhold_conference(selectedConf);
                break;

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

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

    if (calltab_get_selected_type(current_calls_tab) == A_CALL) {
        if (selectedCall) {
            if (!selectedCall->_im_widget)
                selectedCall->_im_widget = im_widget_display(selectedCall->_callID);
        } else
            WARN("Sorry. Instant messaging is not allowed outside a call\n");
    } else {
        if (selectedConf) {
            if (!selectedConf->_im_widget)
                selectedConf->_im_widget = im_widget_display(selectedConf->_confID);
        } 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_tab);

    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_ATTACHED;
            dbus_unhold_conference(selectedConf);
            break;
        case CONFERENCE_STATE_HOLD_RECORD:
            selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD;
            dbus_unhold_conference(selectedConf);
            break;
        case CONFERENCE_STATE_ACTIVE_ATTACHED:
        case CONFERENCE_STATE_ACTIVE_DETACHED:
            selectedConf->_state = CONFERENCE_STATE_HOLD;
            dbus_hold_conference(selectedConf);
            break;
        case CONFERENCE_STATE_ACTIVE_ATTACHED_RECORD:
        case CONFERENCE_STATE_ACTIVE_DETACHED_RECORD:
            selectedConf->_state = CONFERENCE_STATE_HOLD_RECORD;
            dbus_hold_conference(selectedConf);
        default:
            break;
    }
}

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

    if (calllist_get_size(current_calls_tab) > 0) {
        sflphone_pick_up();
    } else if (calllist_get_size(active_calltree_tab) > 0) {
        callable_obj_t *selectedCall = calltab_get_selected_call(active_calltree_tab);

        if (selectedCall) {
            callable_obj_t *new_call = create_new_call(CALL, CALL_STATE_DIALING, "", "", "",
                                       selectedCall->_peer_number);
            calllist_add_call(current_calls_tab, new_call);
            calltree_add_call(current_calls_tab, new_call, NULL);
            sflphone_place_call(new_call);
            calltree_display(current_calls_tab);
        } else {
            sflphone_new_call();
            calltree_display(current_calls_tab);
        }
    } else {
        sflphone_new_call();
        calltree_display(current_calls_tab);
    }
}

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)");
    conference_obj_t * selectedConf = calltab_get_selected_conf(current_calls_tab);

    if (selectedConf)
        dbus_hang_up_conference(selectedConf);
}

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

static void
start_playback_record_cb(void)
{
    DEBUG("UIManager: Start playback button pressed");

    callable_obj_t *selectedCall = calltab_get_selected_call(history_tab);

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

    DEBUG("UIManager: Start selected call file playback %s", selectedCall->_recordfile);
    selectedCall->_record_is_playing = dbus_start_recorded_file_playback(selectedCall->_recordfile);

    update_actions();
}

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

    callable_obj_t *selectedCall = calltab_get_selected_call(history_tab);

    if (selectedCall == 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;
    }

    update_actions();
}

static void
call_configuration_assistant(void * foo UNUSED)
{
    build_wizard();
}

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

    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 = calltab_get_selected_call(active_calltree_tab);

    DEBUG("UIManager: Call back");

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