mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-18 11:38:08 +00:00
1966 lines
75 KiB
C
1966 lines
75 KiB
C
/*
|
|
linphone, gtk-glade interface.
|
|
Copyright (C) 2008-2009 Simon MORLAT (simon.morlat@linphone.org)
|
|
|
|
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "linphone.h"
|
|
#include "linphone/tunnel.h"
|
|
#include "linphone/lpconfig.h"
|
|
#include "config.h"
|
|
|
|
void linphone_gtk_fill_combo_box(GtkWidget *combo, const char **devices, const char *selected, DeviceCap cap){
|
|
const char **p=devices;
|
|
int i=0,active=-1;
|
|
GtkTreeModel *model;
|
|
|
|
|
|
if ((model=gtk_combo_box_get_model(GTK_COMBO_BOX(combo)))==NULL){
|
|
/*case where combo box is created with no model*/
|
|
GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
|
|
model=GTK_TREE_MODEL(gtk_list_store_new(1,G_TYPE_STRING));
|
|
gtk_combo_box_set_model(GTK_COMBO_BOX(combo),model);
|
|
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),renderer,TRUE);
|
|
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,"text",0,NULL);
|
|
}else{
|
|
gtk_list_store_clear(GTK_LIST_STORE(model));
|
|
/* glade creates a combo box without list model and text renderer,
|
|
unless we fill it with a dummy text.
|
|
This dummy text needs to be removed first*/
|
|
}
|
|
|
|
for(;*p!=NULL;++p){
|
|
if ( cap==CAP_IGNORE
|
|
|| (cap==CAP_CAPTURE && linphone_core_sound_device_can_capture(linphone_gtk_get_core(),*p))
|
|
|| (cap==CAP_PLAYBACK && linphone_core_sound_device_can_playback(linphone_gtk_get_core(),*p)) ){
|
|
gtk_combo_box_append_text(GTK_COMBO_BOX(combo),*p);
|
|
if (selected && strcmp(selected,*p)==0) active=i;
|
|
i++;
|
|
}
|
|
}
|
|
if (active!=-1)
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
|
|
}
|
|
|
|
static void linphone_gtk_ldap_display( GtkWidget* param )
|
|
{
|
|
LpConfig* config = linphone_core_get_config(linphone_gtk_get_core());
|
|
LinphoneDictionary* ldap_conf = lp_config_section_to_dict(config,"ldap");
|
|
GtkLabel* label;
|
|
|
|
ms_message("linphone_gtk_ldap_display");
|
|
label= GTK_LABEL(linphone_gtk_get_widget(param,"ldap_server"));
|
|
gtk_label_set_text(label, linphone_dictionary_get_string(ldap_conf,"server", "ldap://localhost") );
|
|
|
|
label = GTK_LABEL(linphone_gtk_get_widget(param,"ldap_auth_method"));
|
|
gtk_label_set_text(label, linphone_dictionary_get_string(ldap_conf,"auth_method", "ANONYMOUS") );
|
|
|
|
label = GTK_LABEL(linphone_gtk_get_widget(param,"ldap_username"));
|
|
gtk_label_set_text(label, linphone_dictionary_get_string(ldap_conf,"username", "") );
|
|
}
|
|
|
|
static void linphone_gtk_ldap_set_authcombo( GtkComboBox* box, const char* authmethod )
|
|
{
|
|
GtkTreeModel* model = GTK_TREE_MODEL(gtk_combo_box_get_model(box));
|
|
GtkTreeIter iter;
|
|
g_return_if_fail(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter) );
|
|
|
|
do{
|
|
const char* value;
|
|
|
|
gtk_tree_model_get(model,&iter,0,&value,-1);
|
|
if( value && strcmp(value, authmethod) == 0){
|
|
gtk_combo_box_set_active_iter(box, &iter);
|
|
break;
|
|
}
|
|
|
|
}while(gtk_tree_model_iter_next(model,&iter));
|
|
}
|
|
|
|
static void linphone_gtk_ldap_load_settings(GtkWidget* param)
|
|
{
|
|
LpConfig* config = linphone_core_get_config(linphone_gtk_get_core());
|
|
LinphoneDictionary* ldap_conf = lp_config_section_to_dict(config,"ldap");
|
|
GtkEntry* entry;
|
|
GtkToggleButton* toggle;
|
|
GtkSpinButton* spin;
|
|
GtkComboBox* cbox;
|
|
|
|
|
|
toggle = GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(param,"ldap_use_tls"));
|
|
gtk_toggle_button_set_active(toggle, linphone_dictionary_get_int(ldap_conf,"use_tls", 0) );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_server"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"server", "ldap://localhost") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_username"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"username", "") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_password"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"password", "") );
|
|
|
|
// SASL
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_bind_dn"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"bind_dn", "") );
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_sasl_authname"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"sasl_authname", "") );
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_sasl_realm"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"sasl_realm", "") );
|
|
|
|
cbox = GTK_COMBO_BOX(linphone_gtk_get_widget(param,"ldap_auth_method"));
|
|
linphone_gtk_ldap_set_authcombo(cbox, linphone_dictionary_get_string(ldap_conf,"auth_method", "ANONYMOUS"));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_base_object"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"base_object", "dc=example,dc=com") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_filter"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"filter", "uid=*%s*") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_name_attribute"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"name_attribute", "cn") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_sip_attribute"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"sip_attribute", "mobile") );
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(param,"ldap_attributes"));
|
|
gtk_entry_set_text(entry, linphone_dictionary_get_string(ldap_conf,"attributes", "cn,givenName,sn,mobile,homePhone") );
|
|
|
|
|
|
toggle = GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(param,"ldap_deref_aliases"));
|
|
gtk_toggle_button_set_active(toggle, linphone_dictionary_get_int(ldap_conf,"deref_aliases", 0) );
|
|
|
|
spin = GTK_SPIN_BUTTON(linphone_gtk_get_widget(param,"ldap_max_results"));
|
|
gtk_spin_button_set_value(spin, linphone_dictionary_get_int(ldap_conf,"max_results", 50) );
|
|
|
|
spin = GTK_SPIN_BUTTON(linphone_gtk_get_widget(param,"ldap_timeout"));
|
|
gtk_spin_button_set_value(spin, linphone_dictionary_get_int(ldap_conf,"timeout", 10) );
|
|
|
|
}
|
|
|
|
|
|
void linphone_gtk_show_ldap_config(GtkWidget* button)
|
|
{
|
|
GtkWidget* param = gtk_widget_get_toplevel(button);
|
|
GtkWidget* ldap_config = linphone_gtk_create_window("ldap", param);
|
|
linphone_gtk_ldap_load_settings(ldap_config);
|
|
|
|
// to refresh parameters when the ldap config is destroyed
|
|
g_object_weak_ref(G_OBJECT(ldap_config), (GWeakNotify)linphone_gtk_ldap_display, (gpointer)param);
|
|
|
|
gtk_widget_show(ldap_config);
|
|
}
|
|
|
|
void linphone_gtk_ldap_reset(GtkWidget *button)
|
|
{
|
|
GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
|
|
ms_message("RESET LDAP");
|
|
gtk_widget_destroy(w);
|
|
}
|
|
|
|
void linphone_gtk_ldap_save(GtkWidget *button)
|
|
{
|
|
LinphoneCore *lc = linphone_gtk_get_core();
|
|
LpConfig* conf = linphone_core_get_config(lc);
|
|
LinphoneDictionary* dict = linphone_dictionary_new();
|
|
|
|
GtkWidget *ldap_widget = gtk_widget_get_toplevel(button);
|
|
GtkEntry* entry;
|
|
GtkToggleButton* toggle;
|
|
GtkSpinButton* spin;
|
|
GtkComboBox* cbox;
|
|
|
|
ms_message("SAVE LDAP");
|
|
|
|
toggle = GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(ldap_widget,"ldap_use_tls"));
|
|
linphone_dictionary_set_int(dict, "use_tls", gtk_toggle_button_get_active(toggle));
|
|
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_server"));
|
|
linphone_dictionary_set_string(dict, "server", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_username"));
|
|
linphone_dictionary_set_string(dict, "username", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_password"));
|
|
linphone_dictionary_set_string(dict, "password", gtk_entry_get_text(entry));
|
|
|
|
// SASL
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_bind_dn"));
|
|
linphone_dictionary_set_string(dict, "bind_dn", gtk_entry_get_text(entry));
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_sasl_authname"));
|
|
linphone_dictionary_set_string(dict, "sasl_authname", gtk_entry_get_text(entry));
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_sasl_realm"));
|
|
linphone_dictionary_set_string(dict, "sasl_realm", gtk_entry_get_text(entry));
|
|
|
|
|
|
cbox = GTK_COMBO_BOX(linphone_gtk_get_widget(ldap_widget,"ldap_auth_method"));
|
|
linphone_dictionary_set_string(dict, "auth_method", gtk_combo_box_get_active_text(cbox));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_base_object"));
|
|
linphone_dictionary_set_string(dict, "base_object", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_filter"));
|
|
linphone_dictionary_set_string(dict, "filter", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_name_attribute"));
|
|
linphone_dictionary_set_string(dict, "name_attribute", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_sip_attribute"));
|
|
linphone_dictionary_set_string(dict, "sip_attribute", gtk_entry_get_text(entry));
|
|
|
|
entry = GTK_ENTRY(linphone_gtk_get_widget(ldap_widget,"ldap_attributes"));
|
|
linphone_dictionary_set_string(dict, "attributes", gtk_entry_get_text(entry));
|
|
|
|
toggle = GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(ldap_widget,"ldap_deref_aliases"));
|
|
linphone_dictionary_set_int(dict, "deref_aliases", gtk_toggle_button_get_active(toggle));
|
|
|
|
spin = GTK_SPIN_BUTTON(linphone_gtk_get_widget(ldap_widget,"ldap_max_results"));
|
|
linphone_dictionary_set_int(dict, "max_results", (int)gtk_spin_button_get_value(spin) );
|
|
|
|
spin = GTK_SPIN_BUTTON(linphone_gtk_get_widget(ldap_widget,"ldap_timeout"));
|
|
linphone_dictionary_set_int(dict, "timeout", (int)gtk_spin_button_get_value(spin) );
|
|
|
|
ms_message("Create LDAP from config");
|
|
// create new LDAP according to the validated config
|
|
linphone_gtk_set_ldap( linphone_ldap_contact_provider_create(lc, dict) );
|
|
// save the config to linphonerc:
|
|
lp_config_load_dict_to_section(conf, "ldap", dict);
|
|
|
|
linphone_dictionary_unref(dict);
|
|
|
|
// close widget
|
|
gtk_widget_destroy(ldap_widget);
|
|
|
|
}
|
|
|
|
void linphone_gtk_fill_video_sizes(GtkWidget *combo){
|
|
int i;
|
|
int active=0;
|
|
char vsize_def[256];
|
|
MSVideoSize cur=linphone_core_get_preferred_video_size(linphone_gtk_get_core());
|
|
const MSVideoSizeDef *def=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());;
|
|
/* glade creates a combo box without list model and text renderer,
|
|
unless we fill it with a dummy text.
|
|
This dummy text needs to be removed first*/
|
|
gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
|
|
for(i=0;def->name!=NULL;++def,++i){
|
|
snprintf(vsize_def,sizeof(vsize_def),"%s (%ix%i)",def->name,def->vsize.width,def->vsize.height);
|
|
gtk_combo_box_append_text(GTK_COMBO_BOX(combo),vsize_def);
|
|
if (cur.width==def->vsize.width && cur.height==def->vsize.height) active=i;
|
|
}
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
|
|
}
|
|
|
|
void linphone_gtk_parameters_closed(GtkWidget *button){
|
|
GtkWidget *pb=gtk_widget_get_toplevel(button);
|
|
gtk_widget_destroy(pb);
|
|
linphone_gtk_update_status_bar_icons();
|
|
}
|
|
|
|
void linphone_gtk_update_my_contact(GtkWidget *w){
|
|
GtkWidget *pb=gtk_widget_get_toplevel(w);
|
|
const char *username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")));
|
|
const char *displayname=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")));
|
|
int port=linphone_core_get_sip_port(linphone_gtk_get_core());
|
|
LinphoneAddress *parsed=linphone_core_get_primary_contact_parsed(linphone_gtk_get_core());
|
|
char *contact;
|
|
g_return_if_fail(parsed!=NULL);
|
|
if (username[0]=='\0') return;
|
|
|
|
linphone_address_set_display_name(parsed,displayname);
|
|
linphone_address_set_username(parsed,username);
|
|
linphone_address_set_port(parsed,port);
|
|
contact=linphone_address_as_string(parsed);
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"sip_address")),contact);
|
|
linphone_core_set_primary_contact(linphone_gtk_get_core(),contact);
|
|
ms_free(contact);
|
|
linphone_address_unref(parsed);
|
|
linphone_gtk_load_identities();
|
|
}
|
|
|
|
void linphone_gtk_set_propety_entry(GtkWidget *w, gboolean stunServer, gboolean ip){
|
|
GtkWidget *stun_entry=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"stun_server");
|
|
GtkWidget *ip_entry=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"nat_address");
|
|
gtk_widget_set_sensitive(stun_entry,stunServer);
|
|
gtk_widget_set_sensitive(ip_entry,ip);
|
|
}
|
|
|
|
void linphone_gtk_stun_server_changed(GtkWidget *w){
|
|
const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
|
|
linphone_core_set_stun_server(linphone_gtk_get_core(),addr);
|
|
}
|
|
|
|
void linphone_gtk_nat_address_changed(GtkWidget *w){
|
|
const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
|
|
linphone_core_set_nat_address(linphone_gtk_get_core(),addr);
|
|
}
|
|
|
|
void linphone_gtk_ipv6_toggled(GtkWidget *w){
|
|
linphone_core_enable_ipv6(linphone_gtk_get_core(),
|
|
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
|
|
}
|
|
|
|
void linphone_gtk_min_audio_port_changed(GtkWidget *w){
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
GtkSpinButton *min_button = GTK_SPIN_BUTTON(w);
|
|
GtkSpinButton *max_button = GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_max_rtp_port"));
|
|
gboolean fixed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_audio_port")));
|
|
|
|
if (fixed) {
|
|
linphone_core_set_audio_port(linphone_gtk_get_core(), (gint) gtk_spin_button_get_value(min_button));
|
|
gtk_spin_button_set_value(max_button, gtk_spin_button_get_value(min_button));
|
|
} else {
|
|
gint min_port = (gint)gtk_spin_button_get_value(min_button);
|
|
gint max_port = (gint)gtk_spin_button_get_value(max_button);
|
|
if (min_port > max_port) {
|
|
gtk_spin_button_set_value(max_button, min_port);
|
|
max_port = min_port;
|
|
}
|
|
linphone_core_set_audio_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_max_audio_port_changed(GtkWidget *w){
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
GtkSpinButton *min_button = GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_min_rtp_port"));
|
|
GtkSpinButton *max_button = GTK_SPIN_BUTTON(w);
|
|
gint min_port = (gint)gtk_spin_button_get_value(min_button);
|
|
gint max_port = (gint)gtk_spin_button_get_value(max_button);
|
|
if (max_port < min_port) {
|
|
gtk_spin_button_set_value(min_button, max_port);
|
|
min_port = max_port;
|
|
}
|
|
linphone_core_set_audio_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
|
|
void linphone_gtk_min_video_port_changed(GtkWidget *w){
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
GtkSpinButton *min_button = GTK_SPIN_BUTTON(w);
|
|
GtkSpinButton *max_button = GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_max_rtp_port"));
|
|
gboolean fixed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_video_port")));
|
|
|
|
if (fixed) {
|
|
linphone_core_set_video_port(linphone_gtk_get_core(), (gint) gtk_spin_button_get_value(min_button));
|
|
gtk_spin_button_set_value(max_button, gtk_spin_button_get_value(min_button));
|
|
} else {
|
|
gint min_port = (gint)gtk_spin_button_get_value(min_button);
|
|
gint max_port = (gint)gtk_spin_button_get_value(max_button);
|
|
if (min_port > max_port) {
|
|
gtk_spin_button_set_value(max_button, min_port);
|
|
max_port = min_port;
|
|
}
|
|
linphone_core_set_video_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_max_video_port_changed(GtkWidget *w){
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
GtkSpinButton *min_button = GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_min_rtp_port"));
|
|
GtkSpinButton *max_button = GTK_SPIN_BUTTON(w);
|
|
gint min_port = (gint)gtk_spin_button_get_value(min_button);
|
|
gint max_port = (gint)gtk_spin_button_get_value(max_button);
|
|
if (max_port < min_port) {
|
|
gtk_spin_button_set_value(min_button, max_port);
|
|
min_port = max_port;
|
|
}
|
|
linphone_core_set_video_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
|
|
void linphone_gtk_no_firewall_toggled(GtkWidget *w){
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
linphone_gtk_set_propety_entry(w,FALSE,FALSE);
|
|
linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyNoFirewall);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_use_nat_address_toggled(GtkWidget *w){
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
linphone_gtk_set_propety_entry(w,FALSE,TRUE);
|
|
linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseNatAddress);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_use_stun_toggled(GtkWidget *w){
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
linphone_gtk_set_propety_entry(w,TRUE,FALSE);
|
|
linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseStun);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_use_ice_toggled(GtkWidget *w){
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
linphone_gtk_set_propety_entry(w,TRUE,FALSE);
|
|
linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseIce);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_use_upnp_toggled(GtkWidget *w){
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
linphone_gtk_set_propety_entry(w,FALSE,FALSE);
|
|
linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseUpnp);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_mtu_changed(GtkWidget *w){
|
|
if (GTK_WIDGET_SENSITIVE(w))
|
|
linphone_core_set_mtu(linphone_gtk_get_core(),(int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
|
|
}
|
|
|
|
void linphone_gtk_use_sip_info_dtmf_toggled(GtkWidget *w){
|
|
linphone_core_set_use_info_for_dtmf(linphone_gtk_get_core(),
|
|
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
|
|
}
|
|
|
|
void linphone_gtk_mtu_set(GtkWidget *w){
|
|
GtkWidget *mtu=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"mtu");
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
|
|
gtk_widget_set_sensitive(mtu,TRUE);
|
|
linphone_gtk_mtu_changed(mtu);
|
|
}else{
|
|
gtk_widget_set_sensitive(mtu,FALSE);
|
|
linphone_core_set_mtu(linphone_gtk_get_core(),0);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_playback_device_changed(GtkWidget *w){
|
|
gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
|
|
linphone_core_set_playback_device(linphone_gtk_get_core(),sel);
|
|
g_free(sel);
|
|
}
|
|
|
|
void linphone_gtk_capture_device_changed(GtkWidget *w){
|
|
gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
|
|
linphone_core_set_capture_device(linphone_gtk_get_core(),sel);
|
|
g_free(sel);
|
|
}
|
|
|
|
void linphone_gtk_ring_device_changed(GtkWidget *w){
|
|
gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
|
|
linphone_core_set_ringer_device(linphone_gtk_get_core(),sel);
|
|
g_free(sel);
|
|
}
|
|
|
|
void linphone_gtk_alsa_special_device_changed(GtkWidget *w){
|
|
/*
|
|
const gchar *dev=gtk_entry_get_text(GTK_ENTRY(w));
|
|
...*/
|
|
}
|
|
|
|
void linphone_gtk_cam_changed(GtkWidget *w){
|
|
LinphoneCall *call;
|
|
LinphoneCore *lc = linphone_gtk_get_core();
|
|
gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
|
|
if (sel){
|
|
if (strcmp(sel, linphone_core_get_video_device(lc)) != 0){
|
|
linphone_core_set_video_device(lc,sel);
|
|
if ((call = linphone_core_get_current_call(lc)) != NULL) {
|
|
linphone_call_update(call, NULL);
|
|
}
|
|
}
|
|
}
|
|
g_free(sel);
|
|
}
|
|
|
|
void linphone_gtk_video_size_changed(GtkWidget *w){
|
|
int sel=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
|
|
const MSVideoSizeDef *defs=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());
|
|
if (sel<0) return;
|
|
linphone_core_set_preferred_video_size(linphone_gtk_get_core(),
|
|
defs[sel].vsize);
|
|
}
|
|
|
|
void linphone_gtk_video_renderer_changed(GtkWidget *w){
|
|
GtkTreeIter iter;
|
|
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(w),&iter)){
|
|
GtkTreeModel *model=gtk_combo_box_get_model(GTK_COMBO_BOX(w));
|
|
gchar *name;
|
|
gtk_tree_model_get(model,&iter,0,&name,-1);
|
|
linphone_core_set_video_display_filter(linphone_gtk_get_core(),name);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_video_preset_changed(GtkWidget *w) {
|
|
gchar *sel = gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
|
|
GtkSpinButton *framerate = GTK_SPIN_BUTTON(linphone_gtk_get_widget(gtk_widget_get_toplevel(w), "video_framerate"));
|
|
LinphoneCore *lc = linphone_gtk_get_core();
|
|
if (g_strcmp0(sel, "default") == 0) {
|
|
linphone_core_set_video_preset(lc, NULL);
|
|
gtk_spin_button_set_value(framerate, 0);
|
|
gtk_widget_set_sensitive(GTK_WIDGET(framerate), FALSE);
|
|
} else if (g_strcmp0(sel, "high-fps") == 0) {
|
|
linphone_core_set_video_preset(lc, "high-fps");
|
|
gtk_spin_button_set_value(framerate, 30);
|
|
gtk_widget_set_sensitive(GTK_WIDGET(framerate), FALSE);
|
|
} else if (g_strcmp0(sel, "custom") == 0) {
|
|
linphone_core_set_video_preset(lc, "custom");
|
|
gtk_spin_button_set_value(framerate, 30);
|
|
gtk_widget_set_sensitive(GTK_WIDGET(framerate), TRUE);
|
|
}
|
|
g_free(sel);
|
|
}
|
|
|
|
void linphone_gtk_ring_file_set(GtkWidget *w){
|
|
gchar *file=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(w));
|
|
linphone_core_set_ring(linphone_gtk_get_core(),file);
|
|
g_free(file);
|
|
}
|
|
|
|
static void linphone_gtk_end_of_ring(LinphoneCore *lc, void *user_data){
|
|
gtk_widget_set_sensitive((GtkWidget*)user_data,TRUE);
|
|
}
|
|
|
|
void linphone_gtk_play_ring_file(GtkWidget *w){
|
|
if (linphone_core_preview_ring(linphone_gtk_get_core(),
|
|
linphone_core_get_ring(linphone_gtk_get_core()),
|
|
linphone_gtk_end_of_ring,
|
|
w)==0){
|
|
gtk_widget_set_sensitive(w,FALSE);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_echo_cancelation_toggled(GtkWidget *w){
|
|
linphone_core_enable_echo_cancellation(linphone_gtk_get_core(),
|
|
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
|
|
}
|
|
|
|
enum {
|
|
CODEC_NAME,
|
|
CODEC_RATE,
|
|
CODEC_BITRATE,
|
|
CODEC_STATUS,
|
|
CODEC_PARAMS,
|
|
CODEC_PRIVDATA,
|
|
CODEC_COLOR,
|
|
CODEC_INFO,
|
|
CODEC_NCOLUMNS
|
|
};
|
|
|
|
static void fmtp_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer userdata){
|
|
GtkListStore *store=(GtkListStore*)userdata;
|
|
GtkTreeIter iter;
|
|
if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),&iter,path)){
|
|
PayloadType *pt;
|
|
gtk_list_store_set(store,&iter,CODEC_PARAMS,new_text,-1);
|
|
gtk_tree_model_get(GTK_TREE_MODEL(store),&iter,CODEC_PRIVDATA,&pt,-1);
|
|
payload_type_set_recv_fmtp(pt,new_text);
|
|
}
|
|
}
|
|
|
|
static void bitrate_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer userdata){
|
|
GtkListStore *store=(GtkListStore*)userdata;
|
|
GtkTreeIter iter;
|
|
float newbitrate=0;
|
|
|
|
if (!new_text) return;
|
|
|
|
if (sscanf(new_text, "%f", &newbitrate)!=1) return;
|
|
|
|
if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),&iter,path)){
|
|
PayloadType *pt;
|
|
gtk_list_store_set(store,&iter,CODEC_BITRATE,newbitrate,-1);
|
|
gtk_tree_model_get(GTK_TREE_MODEL(store),&iter,CODEC_PRIVDATA,&pt,-1);
|
|
linphone_core_set_payload_type_bitrate(linphone_gtk_get_core(), pt, (int)newbitrate);
|
|
}
|
|
}
|
|
|
|
static void linphone_gtk_init_codec_list(GtkTreeView *listview){
|
|
GtkCellRenderer *renderer;
|
|
GtkTreeViewColumn *column;
|
|
GtkTreeSelection *select;
|
|
GValue editable = {0};
|
|
|
|
GtkListStore *store = gtk_list_store_new (CODEC_NCOLUMNS, G_TYPE_STRING,G_TYPE_INT,
|
|
G_TYPE_FLOAT,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_POINTER,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING);
|
|
|
|
gtk_tree_view_set_model(listview,GTK_TREE_MODEL(store));
|
|
g_object_unref(G_OBJECT(store));
|
|
|
|
renderer = gtk_cell_renderer_text_new ();
|
|
column = gtk_tree_view_column_new_with_attributes (_("Name"),
|
|
renderer,
|
|
"text", CODEC_NAME,
|
|
"foreground",CODEC_COLOR,
|
|
NULL);
|
|
gtk_tree_view_append_column (listview, column);
|
|
column = gtk_tree_view_column_new_with_attributes (_("Rate (Hz)"),
|
|
renderer,
|
|
"text", CODEC_RATE,
|
|
"foreground",CODEC_COLOR,
|
|
NULL);
|
|
gtk_tree_view_append_column (listview, column);
|
|
column = gtk_tree_view_column_new_with_attributes (_("Status"),
|
|
renderer,
|
|
"text", CODEC_STATUS,
|
|
"foreground",CODEC_COLOR,
|
|
NULL);
|
|
gtk_tree_view_append_column (listview, column);
|
|
|
|
g_value_init(&editable, G_TYPE_BOOLEAN);
|
|
g_value_set_boolean(&editable, TRUE);
|
|
|
|
renderer = gtk_cell_renderer_text_new ();
|
|
g_object_set_property(G_OBJECT(renderer), "editable", &editable);
|
|
column = gtk_tree_view_column_new_with_attributes (
|
|
_("IP Bitrate (kbit/s)"),
|
|
renderer,
|
|
"text", CODEC_BITRATE,
|
|
"foreground",CODEC_COLOR,
|
|
NULL);
|
|
g_signal_connect(G_OBJECT(renderer),"edited",G_CALLBACK(bitrate_edited),store);
|
|
gtk_tree_view_append_column (listview, column);
|
|
|
|
renderer = gtk_cell_renderer_text_new ();
|
|
g_object_set_property(G_OBJECT(renderer), "editable", &editable);
|
|
column = gtk_tree_view_column_new_with_attributes (
|
|
_("Parameters"),
|
|
renderer,
|
|
"text", CODEC_PARAMS,
|
|
"foreground",CODEC_COLOR,
|
|
NULL);
|
|
g_signal_connect(G_OBJECT(renderer),"edited",G_CALLBACK(fmtp_edited),store);
|
|
gtk_tree_view_append_column (listview, column);
|
|
/* Setup the selection handler */
|
|
select = gtk_tree_view_get_selection (listview);
|
|
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
|
|
}
|
|
|
|
|
|
const char *get_codec_color(LinphoneCore *lc, OrtpPayloadType *pt){
|
|
const gchar *color;
|
|
if (linphone_core_check_payload_type_usability(lc,pt)) color="blue";
|
|
else color="red";
|
|
if (!linphone_core_payload_type_enabled(lc,pt)) {
|
|
color="grey";
|
|
}
|
|
return color;
|
|
}
|
|
|
|
static void linphone_gtk_show_codecs(GtkTreeView *listview, const bctbx_list_t *codeclist)
|
|
{
|
|
const bctbx_list_t *elem;
|
|
GtkTreeIter iter;
|
|
GtkListStore *store=GTK_LIST_STORE(gtk_tree_view_get_model(listview));
|
|
// GtkTreeSelection *selection;
|
|
|
|
gtk_list_store_clear(store);
|
|
|
|
for(elem=codeclist; elem!=NULL; elem=elem->next){
|
|
gchar *status;
|
|
gint rate;
|
|
gfloat bitrate;
|
|
const gchar *color;
|
|
const char *params="";
|
|
|
|
OrtpPayloadType *pt=(OrtpPayloadType *)elem->data;
|
|
|
|
color=get_codec_color(linphone_gtk_get_core(),pt);
|
|
if (linphone_core_payload_type_enabled(linphone_gtk_get_core(),pt)) status=_("Enabled");
|
|
else {
|
|
status=_("Disabled");
|
|
}
|
|
/* get an iterator */
|
|
gtk_list_store_append(store,&iter);
|
|
bitrate=(gfloat)linphone_core_get_payload_type_bitrate(linphone_gtk_get_core(),pt);
|
|
rate=payload_type_get_rate(pt);
|
|
if (pt->recv_fmtp!=NULL) params=pt->recv_fmtp;
|
|
gtk_list_store_set(store,&iter, CODEC_NAME,payload_type_get_mime(pt),
|
|
CODEC_RATE,rate,
|
|
CODEC_BITRATE,bitrate,
|
|
CODEC_STATUS,status,
|
|
CODEC_PARAMS,params,
|
|
CODEC_PRIVDATA,(gpointer)pt,
|
|
CODEC_COLOR,(gpointer)color,
|
|
CODEC_INFO,(gpointer)linphone_core_get_payload_type_description(linphone_gtk_get_core(),pt),
|
|
-1);
|
|
}
|
|
|
|
|
|
|
|
/* Setup the selection handler */
|
|
// selection = gtk_tree_view_get_selection (listview);
|
|
// gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
|
|
//gtk_tree_view_columns_autosize(GTK_TREE_VIEW (sec->interfaces));
|
|
#if GTK_CHECK_VERSION(2,12,0)
|
|
gtk_tree_view_set_tooltip_column(listview,CODEC_INFO);
|
|
#endif
|
|
}
|
|
|
|
static void linphone_gtk_check_codec_bandwidth(GtkTreeView *v){
|
|
GtkTreeIter iter;
|
|
GtkTreeModel *model;
|
|
model=gtk_tree_view_get_model(v);
|
|
g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
|
|
do{
|
|
PayloadType *pt=NULL;
|
|
|
|
gfloat bitrate;
|
|
gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
|
|
|
|
bitrate=(gfloat)linphone_core_get_payload_type_bitrate(linphone_gtk_get_core(),pt);
|
|
gtk_list_store_set(GTK_LIST_STORE(model),&iter,CODEC_COLOR, (gpointer)get_codec_color(linphone_gtk_get_core(),pt),
|
|
CODEC_BITRATE, bitrate,-1);
|
|
}while(gtk_tree_model_iter_next(model,&iter));
|
|
}
|
|
|
|
static void linphone_gtk_select_codec(GtkTreeView *v, PayloadType *ref){
|
|
GtkTreeIter iter;
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
selection=gtk_tree_view_get_selection(v);
|
|
model=gtk_tree_view_get_model(v);
|
|
g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
|
|
do{
|
|
PayloadType *pt=NULL;
|
|
gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
|
|
if (pt==ref){
|
|
gtk_tree_selection_select_iter(selection,&iter);
|
|
}
|
|
|
|
}while(gtk_tree_model_iter_next(model,&iter));
|
|
}
|
|
|
|
static void linphone_gtk_draw_codec_list(GtkTreeView *v, int type){ /* 0=audio, 1=video*/
|
|
const bctbx_list_t *list;
|
|
if (type==0) list=linphone_core_get_audio_codecs(linphone_gtk_get_core());
|
|
else list=linphone_core_get_video_codecs(linphone_gtk_get_core());
|
|
linphone_gtk_show_codecs(v,list);
|
|
}
|
|
|
|
void linphone_gtk_download_bw_changed(GtkWidget *w){
|
|
GtkTreeView *audiov=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"audio_codec_list"));
|
|
GtkTreeView *videov=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"video_codec_list"));
|
|
linphone_core_set_download_bandwidth(linphone_gtk_get_core(),
|
|
(int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
|
|
linphone_gtk_check_codec_bandwidth(audiov);
|
|
linphone_gtk_check_codec_bandwidth(videov);
|
|
}
|
|
|
|
void linphone_gtk_upload_bw_changed(GtkWidget *w){
|
|
GtkTreeView *audiov=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"audio_codec_list"));
|
|
GtkTreeView *videov=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"video_codec_list"));
|
|
linphone_core_set_upload_bandwidth(linphone_gtk_get_core(),
|
|
(int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
|
|
linphone_gtk_check_codec_bandwidth(audiov);
|
|
linphone_gtk_check_codec_bandwidth(videov);
|
|
}
|
|
|
|
void linphone_gtk_video_framerate_changed(GtkWidget *w) {
|
|
linphone_core_set_preferred_framerate(linphone_gtk_get_core(),
|
|
(float)(int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
|
|
}
|
|
|
|
void linphone_gtk_adaptive_rate_control_toggled(GtkToggleButton *button){
|
|
gboolean active=gtk_toggle_button_get_active(button);
|
|
linphone_core_enable_adaptive_rate_control(linphone_gtk_get_core(),active);
|
|
}
|
|
|
|
static void _g_list_func_destroy_tree_path(gpointer data, gpointer user_data) {
|
|
GtkTreePath *tree_path = (GtkTreePath *)data;
|
|
gtk_tree_path_free(tree_path);
|
|
}
|
|
|
|
static void linphone_gtk_codec_move(GtkWidget *button, int dir, int type){ /* 0=audio, 1=video*/
|
|
GtkTreeView *v;
|
|
GtkTreeSelection *sel;
|
|
GtkTreeModel *mod;
|
|
GtkTreeIter iter;
|
|
PayloadType *pt=NULL;
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
|
|
if (type == 0) v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"audio_codec_list"));
|
|
else v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"video_codec_list"));
|
|
sel=gtk_tree_view_get_selection(v);
|
|
if (gtk_tree_selection_count_selected_rows(sel) == 1){
|
|
bctbx_list_t *sel_elem,*before;
|
|
bctbx_list_t *codec_list;
|
|
|
|
GList *selected_rows = gtk_tree_selection_get_selected_rows(sel, &mod);
|
|
gtk_tree_model_get_iter(mod, &iter, (GtkTreePath *)g_list_nth_data(selected_rows, 0));
|
|
gtk_tree_model_get(mod,&iter,CODEC_PRIVDATA,&pt,-1);
|
|
g_list_foreach(selected_rows, _g_list_func_destroy_tree_path, NULL);
|
|
g_list_free(selected_rows);
|
|
|
|
if (pt->type==PAYLOAD_VIDEO)
|
|
codec_list=bctbx_list_copy(linphone_core_get_video_codecs(lc));
|
|
else codec_list=bctbx_list_copy(linphone_core_get_audio_codecs(lc));
|
|
sel_elem=bctbx_list_find(codec_list,pt);
|
|
if (dir>0) {
|
|
if (sel_elem->prev) before=sel_elem->prev;
|
|
else before=sel_elem;
|
|
codec_list=bctbx_list_insert(codec_list,before,pt);
|
|
}
|
|
else{
|
|
if (sel_elem->next) before=sel_elem->next->next;
|
|
else before=sel_elem;
|
|
codec_list=bctbx_list_insert(codec_list,before,pt);
|
|
}
|
|
codec_list=bctbx_list_erase_link(codec_list,sel_elem);
|
|
if (pt->type==PAYLOAD_VIDEO)
|
|
linphone_core_set_video_codecs(lc,codec_list);
|
|
else linphone_core_set_audio_codecs(lc,codec_list);
|
|
linphone_gtk_show_codecs(v,codec_list);
|
|
linphone_gtk_select_codec(v,pt);
|
|
}
|
|
}
|
|
|
|
static void linphone_gtk_codec_set_enable(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) {
|
|
PayloadType *pt=NULL;
|
|
gboolean *enabled = (gboolean *)data;
|
|
gtk_tree_model_get(model, iter, CODEC_PRIVDATA, &pt, -1);
|
|
linphone_core_enable_payload_type(linphone_gtk_get_core(), pt, *enabled);
|
|
gtk_list_store_set(GTK_LIST_STORE(model), iter, CODEC_STATUS, *enabled ? _("Enabled") : _("Disabled"),
|
|
CODEC_COLOR,(gpointer)get_codec_color(linphone_gtk_get_core(),pt), -1);
|
|
}
|
|
|
|
static void linphone_gtk_codec_set_enable_all_selected(GtkWidget *button, gboolean enabled, int type){ /* 0=audio, 1=video*/
|
|
GtkTreeView *v;
|
|
GtkTreeSelection *sel;
|
|
if (type == 0) v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"audio_codec_list"));
|
|
else v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"video_codec_list"));
|
|
sel=gtk_tree_view_get_selection(v);
|
|
gtk_tree_selection_selected_foreach(sel, linphone_gtk_codec_set_enable, &enabled);
|
|
if (type == 0){
|
|
/*activating audio and video codecs has consequences on video bandwidth*/
|
|
GtkTreeView *videov=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"video_codec_list"));
|
|
linphone_gtk_check_codec_bandwidth(videov);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_audio_codec_up(GtkWidget *button){
|
|
linphone_gtk_codec_move(button,+1,0);
|
|
}
|
|
|
|
void linphone_gtk_audio_codec_down(GtkWidget *button){
|
|
linphone_gtk_codec_move(button,-1,0);
|
|
}
|
|
|
|
void linphone_gtk_audio_codec_enable(GtkWidget *button){
|
|
linphone_gtk_codec_set_enable_all_selected(button,TRUE,0);
|
|
}
|
|
|
|
void linphone_gtk_audio_codec_disable(GtkWidget *button){
|
|
linphone_gtk_codec_set_enable_all_selected(button,FALSE,0);
|
|
}
|
|
|
|
void linphone_gtk_video_codec_up(GtkWidget *button){
|
|
linphone_gtk_codec_move(button,+1,1);
|
|
}
|
|
|
|
void linphone_gtk_video_codec_down(GtkWidget *button){
|
|
linphone_gtk_codec_move(button,-1,1);
|
|
}
|
|
|
|
void linphone_gtk_video_codec_enable(GtkWidget *button){
|
|
linphone_gtk_codec_set_enable_all_selected(button,TRUE,1);
|
|
}
|
|
|
|
void linphone_gtk_video_codec_disable(GtkWidget *button){
|
|
linphone_gtk_codec_set_enable_all_selected(button,FALSE,1);
|
|
}
|
|
|
|
void linphone_gtk_clear_passwords(GtkWidget *button){
|
|
linphone_core_clear_all_auth_info(linphone_gtk_get_core());
|
|
}
|
|
|
|
enum{
|
|
PROXY_CONFIG_IDENTITY,
|
|
PROXY_CONFIG_REF,
|
|
PROXY_CONFIG_NCOL
|
|
};
|
|
|
|
void linphone_gtk_show_sip_accounts(GtkWidget *w){
|
|
GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"proxy_list"));
|
|
GtkTreeModel *model=gtk_tree_view_get_model(v);
|
|
GtkListStore *store;
|
|
GtkTreeSelection *select;
|
|
const LinphoneProxyConfig *default_pc = linphone_core_get_default_proxy_config(linphone_gtk_get_core());
|
|
GtkTreePath *default_pc_path = NULL;
|
|
|
|
const bctbx_list_t *elem;
|
|
if (!model){
|
|
GtkCellRenderer *renderer;
|
|
GtkTreeViewColumn *column;
|
|
/* create the proxy list */
|
|
store = gtk_list_store_new (PROXY_CONFIG_NCOL, G_TYPE_STRING, G_TYPE_POINTER);
|
|
|
|
gtk_tree_view_set_model(v,GTK_TREE_MODEL(store));
|
|
g_object_unref(G_OBJECT(store));
|
|
renderer = gtk_cell_renderer_text_new ();
|
|
column = gtk_tree_view_column_new_with_attributes (_("Account"),
|
|
renderer,
|
|
"text", PROXY_CONFIG_IDENTITY,
|
|
NULL);
|
|
gtk_tree_view_append_column (v, column);
|
|
|
|
select = gtk_tree_view_get_selection (v);
|
|
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
|
|
model=GTK_TREE_MODEL(store);
|
|
}else {
|
|
store=GTK_LIST_STORE(model);
|
|
}
|
|
gtk_list_store_clear(store);
|
|
for(elem=linphone_core_get_proxy_config_list(linphone_gtk_get_core());elem!=NULL;elem=bctbx_list_next(elem)){
|
|
LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
|
|
GtkTreeIter iter;
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,PROXY_CONFIG_IDENTITY,linphone_proxy_config_get_identity(cfg),
|
|
PROXY_CONFIG_REF,cfg,-1);
|
|
if(cfg == default_pc) default_pc_path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
|
|
}
|
|
if(default_pc_path) {
|
|
gtk_tree_selection_select_path(gtk_tree_view_get_selection(v), default_pc_path);
|
|
gtk_tree_path_free(default_pc_path);
|
|
}
|
|
}
|
|
|
|
static void linphone_gtk_proxy_closed(GtkWidget *w){
|
|
LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
|
|
gboolean was_editing=! GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w),"is_new"));
|
|
if (cfg){
|
|
if (was_editing){
|
|
linphone_proxy_config_done(cfg);
|
|
}else linphone_proxy_config_destroy(cfg);
|
|
}
|
|
}
|
|
|
|
static void fill_transport_combo_box(GtkWidget *combo, LinphoneTransportType choice, gboolean is_sensitive){
|
|
GtkTreeModel *model;
|
|
GtkTreeIter iter;
|
|
|
|
if (GPOINTER_TO_INT(g_object_get_data(G_OBJECT(combo),"combo-updating"))) return;
|
|
|
|
if ((model=gtk_combo_box_get_model(GTK_COMBO_BOX(combo)))==NULL){
|
|
/*case where combo box is created with no model*/
|
|
GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
|
|
model=GTK_TREE_MODEL(gtk_list_store_new(1,G_TYPE_STRING));
|
|
gtk_combo_box_set_model(GTK_COMBO_BOX(combo),model);
|
|
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),renderer,TRUE);
|
|
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,"markup",0,NULL);
|
|
}
|
|
if (!gtk_tree_model_get_iter_first(model,&iter)){
|
|
gtk_list_store_append(GTK_LIST_STORE(model),&iter);
|
|
gtk_list_store_set(GTK_LIST_STORE(model),&iter,0,"UDP",-1);
|
|
gtk_list_store_append(GTK_LIST_STORE(model),&iter);
|
|
gtk_list_store_set(GTK_LIST_STORE(model),&iter,0,"TCP",-1);
|
|
if (linphone_core_sip_transport_supported(linphone_gtk_get_core(),LinphoneTransportTls)){
|
|
gtk_list_store_append(GTK_LIST_STORE(model),&iter);
|
|
gtk_list_store_set(GTK_LIST_STORE(model),&iter,0,"TLS",-1);
|
|
}
|
|
}
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),(int)choice);
|
|
gtk_widget_set_sensitive(combo,is_sensitive);
|
|
}
|
|
|
|
static void update_proxy_transport(GtkWidget *w){
|
|
const char *addr=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy")));
|
|
LinphoneAddress *laddr=linphone_address_new(addr);
|
|
if (laddr){
|
|
GtkWidget *combo=linphone_gtk_get_widget(w,"transport");
|
|
if (linphone_address_is_secure(laddr)){
|
|
fill_transport_combo_box(combo,LinphoneTransportTls,FALSE);
|
|
}else{
|
|
fill_transport_combo_box(combo,linphone_address_get_transport(laddr),TRUE);
|
|
}
|
|
linphone_address_unref(laddr);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_proxy_transport_changed(GtkWidget *combo){
|
|
GtkWidget *w=gtk_widget_get_toplevel(combo);
|
|
int index=gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
|
|
GtkWidget *proxy=linphone_gtk_get_widget(w,"proxy");
|
|
const char *addr=gtk_entry_get_text(GTK_ENTRY(proxy));
|
|
LinphoneAddress *laddr;
|
|
LinphoneTransportType new_transport=(LinphoneTransportType)index;
|
|
|
|
if (index==-1) return;
|
|
|
|
g_object_set_data(G_OBJECT(w),"combo-updating",GINT_TO_POINTER(1));
|
|
laddr=linphone_address_new(addr);
|
|
if (laddr){
|
|
if (linphone_address_get_transport(laddr)!=new_transport){
|
|
char *newaddr;
|
|
linphone_address_set_transport(laddr,new_transport);
|
|
newaddr=linphone_address_as_string(laddr);
|
|
gtk_entry_set_text(GTK_ENTRY(proxy),newaddr);
|
|
ms_free(newaddr);
|
|
}
|
|
linphone_address_unref(laddr);
|
|
}
|
|
g_object_set_data(G_OBJECT(w),"combo-updating",GINT_TO_POINTER(0));
|
|
}
|
|
|
|
void linphone_gtk_proxy_address_changed(GtkEditable *editable){
|
|
update_proxy_transport(gtk_widget_get_toplevel(GTK_WIDGET(editable)));
|
|
}
|
|
|
|
void linphone_gtk_show_proxy_config(GtkWidget *pb, LinphoneProxyConfig *cfg){
|
|
GtkWidget *w=linphone_gtk_create_window("sip_account", gtk_widget_get_toplevel(pb));
|
|
const char *tmp;
|
|
gboolean is_new=FALSE;
|
|
|
|
if (!cfg) {
|
|
cfg=linphone_core_create_proxy_config(linphone_gtk_get_core());
|
|
is_new=TRUE;
|
|
g_object_set_data(G_OBJECT(w),"is_new",GINT_TO_POINTER(TRUE));
|
|
}
|
|
|
|
if (!is_new){
|
|
linphone_proxy_config_edit(cfg);
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity")),
|
|
linphone_proxy_config_get_identity(cfg));
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy")),linphone_proxy_config_get_addr(cfg));
|
|
tmp=linphone_proxy_config_get_route(cfg);
|
|
if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route")),tmp);
|
|
tmp=linphone_proxy_config_get_contact_parameters(cfg);
|
|
if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"params")),tmp);
|
|
}
|
|
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod")),
|
|
linphone_proxy_config_get_expires(cfg));
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register")),
|
|
linphone_proxy_config_register_enabled(cfg));
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish")),
|
|
linphone_proxy_config_publish_enabled(cfg));
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"avpf")),
|
|
linphone_proxy_config_avpf_enabled(cfg));
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"avpf_rr_interval")),
|
|
linphone_proxy_config_get_avpf_rr_interval(cfg));
|
|
|
|
g_object_set_data(G_OBJECT(w),"config",(gpointer)cfg);
|
|
g_object_set_data(G_OBJECT(w),"parameters",(gpointer)pb);
|
|
g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_proxy_closed,w);
|
|
gtk_widget_show(w);
|
|
}
|
|
|
|
void linphone_gtk_proxy_cancel(GtkButton *button){
|
|
GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
|
|
gtk_widget_destroy(w);
|
|
}
|
|
|
|
void linphone_gtk_proxy_ok(GtkButton *button){
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
|
|
LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
|
|
int index=gtk_combo_box_get_active(GTK_COMBO_BOX(linphone_gtk_get_widget(w,"transport")));
|
|
LinphoneTransportType tport=(LinphoneTransportType)index;
|
|
gboolean was_editing=! GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w),"is_new"));
|
|
|
|
linphone_proxy_config_set_identity(cfg,
|
|
gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity"))));
|
|
if (linphone_proxy_config_set_server_addr(cfg,
|
|
gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy"))))==0){
|
|
if (index!=-1){
|
|
/*make sure transport was added to proxy address*/
|
|
LinphoneAddress *laddr=linphone_address_new(linphone_proxy_config_get_addr(cfg));
|
|
if (laddr){
|
|
if (linphone_address_get_transport(laddr)!=tport){
|
|
char *tmp;
|
|
linphone_address_set_transport(laddr,tport);
|
|
tmp=linphone_address_as_string(laddr);
|
|
linphone_proxy_config_set_server_addr(cfg,tmp);
|
|
ms_free(tmp);
|
|
}
|
|
linphone_address_unref(laddr);
|
|
}
|
|
}
|
|
}
|
|
linphone_proxy_config_set_route(cfg,
|
|
gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route"))));
|
|
linphone_proxy_config_set_contact_parameters(cfg,
|
|
gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"params"))));
|
|
linphone_proxy_config_set_expires(cfg,
|
|
(int)gtk_spin_button_get_value(
|
|
GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod"))));
|
|
linphone_proxy_config_enable_publish(cfg,
|
|
gtk_toggle_button_get_active(
|
|
GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish"))));
|
|
linphone_proxy_config_enable_register(cfg,
|
|
gtk_toggle_button_get_active(
|
|
GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register"))));
|
|
linphone_proxy_config_enable_avpf(cfg,
|
|
gtk_toggle_button_get_active(
|
|
GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"avpf"))));
|
|
linphone_proxy_config_set_avpf_rr_interval(cfg,
|
|
(int)gtk_spin_button_get_value(
|
|
GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"avpf_rr_interval"))));
|
|
|
|
/* check if tls was asked but is not enabled in transport configuration*/
|
|
if (tport==LinphoneTransportTls){
|
|
LCSipTransports tports;
|
|
linphone_core_get_sip_transports(lc,&tports);
|
|
if (tports.tls_port==LC_SIP_TRANSPORT_DISABLED){
|
|
tports.tls_port=LC_SIP_TRANSPORT_RANDOM;
|
|
}
|
|
linphone_core_set_sip_transports(lc,&tports);
|
|
}
|
|
|
|
if (was_editing){
|
|
if (linphone_proxy_config_done(cfg)==-1)
|
|
return;
|
|
}
|
|
else {
|
|
if (linphone_core_add_proxy_config(linphone_gtk_get_core(),cfg)==-1) return;
|
|
linphone_core_set_default_proxy(linphone_gtk_get_core(),cfg);
|
|
}
|
|
g_object_set_data(G_OBJECT(w),"config",NULL);
|
|
linphone_gtk_show_sip_accounts(GTK_WIDGET(g_object_get_data(G_OBJECT(w),"parameters")));
|
|
gtk_widget_destroy(w);
|
|
/* also update the main window's list of identities*/
|
|
linphone_gtk_load_identities();
|
|
}
|
|
|
|
static LinphoneProxyConfig *linphone_gtk_get_selected_proxy_config(GtkWidget* pb){
|
|
GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(pb,"proxy_list"));
|
|
GtkTreeSelection *selection=gtk_tree_view_get_selection(v);
|
|
GtkTreeIter iter;
|
|
GtkTreeModel *model;
|
|
if (gtk_tree_selection_get_selected(selection,&model,&iter)){
|
|
LinphoneProxyConfig *cfg=NULL;
|
|
gtk_tree_model_get(model,&iter,PROXY_CONFIG_REF,&cfg,-1);
|
|
return cfg;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void linphone_gtk_add_proxy(GtkButton *button){
|
|
linphone_gtk_show_proxy_config(gtk_widget_get_toplevel(GTK_WIDGET(button)),NULL);
|
|
}
|
|
|
|
void linphone_gtk_remove_proxy(GtkButton *button){
|
|
LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(
|
|
gtk_widget_get_toplevel(GTK_WIDGET(button)));
|
|
if (cfg){
|
|
linphone_core_remove_proxy_config(linphone_gtk_get_core(),cfg);
|
|
linphone_gtk_show_sip_accounts(gtk_widget_get_toplevel(GTK_WIDGET(button)));
|
|
/* also update the main window's list of identities*/
|
|
linphone_gtk_load_identities();
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_edit_proxy(GtkButton *button){
|
|
GtkWidget *pb=gtk_widget_get_toplevel(GTK_WIDGET(button));
|
|
LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(pb);
|
|
if (cfg){
|
|
linphone_gtk_show_proxy_config(pb,cfg);
|
|
/* also update the main window's list of identities*/
|
|
linphone_gtk_load_identities();
|
|
}
|
|
}
|
|
|
|
typedef struct _LangCodes{
|
|
const char *code;
|
|
const char *name;
|
|
}LangCodes;
|
|
|
|
static LangCodes supported_langs[]={
|
|
{ "C" , N_("English") },
|
|
{ "fr" , N_("French") },
|
|
{ "sv" , N_("Swedish") },
|
|
{ "it" , N_("Italian") },
|
|
{ "es" , N_("Spanish") },
|
|
{ "pt_BR" , N_("Brazilian Portugese") },
|
|
{ "pl" , N_("Polish") },
|
|
{ "de" , N_("German") },
|
|
{ "ru" , N_("Russian") },
|
|
{ "ja" , N_("Japanese") },
|
|
{ "nl" , N_("Dutch") },
|
|
{ "hu" , N_("Hungarian") },
|
|
{ "cs" , N_("Czech") },
|
|
{ "zh_CN" , N_("Chinese") },
|
|
{ "zh_TW" , N_("Traditional Chinese") },
|
|
{ "nb_NO" , N_("Norwegian") },
|
|
{ "he" , N_("Hebrew") },
|
|
{ "sr" , N_("Serbian") },
|
|
{ "ar" , N_("Arabic") },
|
|
{ "tr" , N_("Turkish") },
|
|
{ "fi" , N_("Finnish") },
|
|
{ "lt" , N_("Lithuanian") },
|
|
{ NULL , NULL }
|
|
};
|
|
|
|
static const char *lang_get_name(const char *code){
|
|
LangCodes *p=supported_langs;
|
|
while(p->code!=NULL){
|
|
if (strcmp(p->code,code)==0) return p->name;
|
|
p++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean lang_equals(const char *l1, const char *l2){
|
|
return ((strncmp(l1,l2,5)==0 || strncmp(l1,l2,2)==0));
|
|
}
|
|
|
|
static void linphone_gtk_fill_langs(GtkWidget *pb){
|
|
GtkWidget *combo=linphone_gtk_get_widget(pb,"lang_combo");
|
|
char code[10];
|
|
const char *all_langs="C " LINPHONE_ALL_LANGS;
|
|
const char *name;
|
|
int i=0,index=0;
|
|
int cur_lang_index=-1;
|
|
char text[256]={0};
|
|
const char *cur_lang = g_getenv("LANGUAGE");
|
|
if (cur_lang==NULL) cur_lang="C";
|
|
/* glade creates a combo box without list model and text renderer,
|
|
unless we fill it with a dummy text.
|
|
This dummy text needs to be removed first*/
|
|
gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
|
|
while(sscanf(all_langs+i,"%s",code)==1){
|
|
i+=strlen(code);
|
|
while(all_langs[i]==' ') ++i;
|
|
name=lang_get_name(code);
|
|
snprintf(text,sizeof(text)-1,"%s : %s",code,name!=NULL ? _(name) : code);
|
|
gtk_combo_box_append_text(GTK_COMBO_BOX(combo),text);
|
|
if (cur_lang_index==-1 && lang_equals(cur_lang,code))
|
|
cur_lang_index=index;
|
|
index++;
|
|
}
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),cur_lang_index);
|
|
}
|
|
|
|
void linphone_gtk_lang_changed(GtkComboBox *combo){
|
|
const char *selected=gtk_combo_box_get_active_text(combo);
|
|
char code[10];
|
|
const char *cur_lang=g_getenv("LANGUAGE");
|
|
if (selected!=NULL){
|
|
sscanf(selected,"%s",code);
|
|
if (cur_lang==NULL) cur_lang="C";
|
|
if (!lang_equals(cur_lang,code)){
|
|
GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(combo))),
|
|
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
GTK_MESSAGE_INFO,
|
|
GTK_BUTTONS_CLOSE,
|
|
"%s",
|
|
(const gchar*)_("You need to restart linphone for the new language selection to take effect."));
|
|
/* Destroy the dialog when the user responds to it (e.g. clicks a button) */
|
|
g_signal_connect_swapped (G_OBJECT (dialog), "response",
|
|
G_CALLBACK (gtk_widget_destroy),
|
|
G_OBJECT (dialog));
|
|
gtk_widget_show(dialog);
|
|
linphone_gtk_set_lang(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void linphone_gtk_ui_level_adapt(GtkWidget *top) {
|
|
gboolean ui_advanced;
|
|
const char *simple_ui = linphone_gtk_get_ui_config("simple_ui", "parameters.codec_tab parameters.transport_frame parameters.ports_frame parameters.bandwidth_frame");
|
|
|
|
ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", FALSE);
|
|
if (ui_advanced) {
|
|
linphone_gtk_visibility_set(simple_ui, "parameters", top, TRUE);
|
|
} else {
|
|
linphone_gtk_visibility_set(simple_ui, "parameters", top, FALSE);
|
|
}
|
|
}
|
|
|
|
void linphone_gtk_ui_level_toggled(GtkWidget *w) {
|
|
gint ui_advanced;
|
|
GtkWidget *top;
|
|
|
|
top = gtk_widget_get_toplevel(w);
|
|
ui_advanced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
|
|
linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
|
|
linphone_gtk_ui_level_adapt(top);
|
|
}
|
|
|
|
static void linphone_gtk_set_media_encryption_mandatory_sensitive(GtkWidget *propbox, gboolean val){
|
|
GtkWidget *w=linphone_gtk_get_widget(propbox,"media_encryption_mandatory_checkbox");
|
|
gtk_widget_set_sensitive(w,val);
|
|
}
|
|
|
|
static void linphone_gtk_media_encryption_changed(GtkWidget *combo){
|
|
char *selected=gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo));
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
GtkWidget *toplevel=gtk_widget_get_toplevel(combo);
|
|
GtkWidget *mandatory_box = linphone_gtk_get_widget(toplevel,"media_encryption_mandatory_checkbox");
|
|
if (selected!=NULL){
|
|
if (strcasecmp(selected,"SRTP")==0){
|
|
linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionSRTP);
|
|
gtk_widget_set_sensitive(mandatory_box,TRUE);
|
|
}else if (strcasecmp(selected,"DTLS")==0){
|
|
linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionDTLS);
|
|
gtk_widget_set_sensitive(mandatory_box,TRUE);
|
|
}else if (strcasecmp(selected,"ZRTP")==0){
|
|
linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionZRTP);
|
|
gtk_widget_set_sensitive(mandatory_box,TRUE);
|
|
} else {
|
|
linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionNone);
|
|
gtk_widget_set_sensitive(mandatory_box,FALSE);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mandatory_box), FALSE);
|
|
}
|
|
g_free(selected);
|
|
}else g_warning("gtk_combo_box_get_active_text() returned NULL");
|
|
}
|
|
|
|
void linphone_gtk_set_media_encryption_mandatory(GtkWidget *button){
|
|
linphone_core_set_media_encryption_mandatory(linphone_gtk_get_core(),gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
|
|
}
|
|
|
|
void linphone_gtk_lime_changed(GtkComboBoxText *combotext) {
|
|
linphone_core_enable_lime(linphone_gtk_get_core(), gtk_combo_box_get_active(GTK_COMBO_BOX(combotext)));
|
|
}
|
|
|
|
static void linphone_gtk_show_media_encryption(GtkWidget *pb){
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
GtkWidget *combo=linphone_gtk_get_widget(pb,"media_encryption_combo");
|
|
bool_t no_enc=TRUE;
|
|
int srtp_id=-1,zrtp_id=-1,dtls_id=-1;
|
|
GtkTreeModel *model;
|
|
GtkListStore *store;
|
|
GtkTreeIter iter;
|
|
GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
|
|
|
|
model=GTK_TREE_MODEL((store=gtk_list_store_new(1,G_TYPE_STRING)));
|
|
gtk_combo_box_set_model(GTK_COMBO_BOX(combo),model);
|
|
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),renderer,TRUE);
|
|
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,"text",0,NULL);
|
|
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,0,_("None"),-1);
|
|
|
|
if (linphone_core_media_encryption_supported(lc,LinphoneMediaEncryptionSRTP)){
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,0,_("SRTP"),-1);
|
|
srtp_id=1;
|
|
no_enc=FALSE;
|
|
}
|
|
if (linphone_core_media_encryption_supported(lc,LinphoneMediaEncryptionDTLS)){
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,0,_("DTLS"),-1);
|
|
if (srtp_id!=-1) dtls_id=2;
|
|
else dtls_id=1;
|
|
no_enc=FALSE;
|
|
}
|
|
if (linphone_core_media_encryption_supported(lc,LinphoneMediaEncryptionZRTP)){
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,0,_("ZRTP"),-1);
|
|
no_enc=FALSE;
|
|
if (srtp_id!=-1) {
|
|
if (dtls_id!=-1)
|
|
zrtp_id=3;
|
|
else zrtp_id=2;
|
|
} else {
|
|
if (dtls_id!=-1)
|
|
zrtp_id=2;
|
|
else zrtp_id=1;
|
|
}
|
|
}
|
|
if (no_enc){
|
|
/*hide this setting*/
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb,"encryption_label"));
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb,"encryption_table"));
|
|
}else{
|
|
LinphoneMediaEncryption menc=linphone_core_get_media_encryption(lc);
|
|
gtk_widget_show(linphone_gtk_get_widget(pb,"encryption_label"));
|
|
gtk_widget_show(linphone_gtk_get_widget(pb,"encryption_table"));
|
|
|
|
switch(menc){
|
|
case LinphoneMediaEncryptionNone:
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),0);
|
|
linphone_gtk_set_media_encryption_mandatory_sensitive(pb,FALSE);
|
|
break;
|
|
case LinphoneMediaEncryptionSRTP:
|
|
if (srtp_id!=-1) {
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),srtp_id);
|
|
linphone_gtk_set_media_encryption_mandatory_sensitive(pb,TRUE);
|
|
}
|
|
break;
|
|
case LinphoneMediaEncryptionDTLS:
|
|
if (dtls_id!=-1) {
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),dtls_id);
|
|
linphone_gtk_set_media_encryption_mandatory_sensitive(pb,TRUE);
|
|
}
|
|
break;
|
|
case LinphoneMediaEncryptionZRTP:
|
|
if (zrtp_id!=-1) {
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(combo),zrtp_id);
|
|
linphone_gtk_set_media_encryption_mandatory_sensitive(pb,TRUE);
|
|
}
|
|
break;
|
|
}
|
|
g_signal_connect(G_OBJECT(combo),"changed",(GCallback)linphone_gtk_media_encryption_changed,NULL);
|
|
}
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"media_encryption_mandatory_checkbox")),
|
|
linphone_core_is_media_encryption_mandatory(lc));
|
|
|
|
gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"chat_lime_combo")), linphone_core_lime_enabled(lc));
|
|
gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"chat_lime_combo"), linphone_core_lime_available(lc));
|
|
|
|
g_object_unref(G_OBJECT(model));
|
|
}
|
|
|
|
void linphone_gtk_parameters_destroyed(GtkWidget *pb){
|
|
GtkWidget *mw=linphone_gtk_get_main_window();
|
|
g_object_set_data(G_OBJECT(mw),"parameters",NULL);
|
|
}
|
|
|
|
void linphone_gtk_fill_soundcards(GtkWidget *pb){
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
const char **sound_devices=linphone_core_get_sound_devices(lc);
|
|
linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"playback_device"), sound_devices,
|
|
linphone_core_get_playback_device(lc),CAP_PLAYBACK);
|
|
linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"ring_device"), sound_devices,
|
|
linphone_core_get_ringer_device(lc),CAP_PLAYBACK);
|
|
linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"capture_device"), sound_devices,
|
|
linphone_core_get_capture_device(lc), CAP_CAPTURE);
|
|
}
|
|
|
|
void linphone_gtk_fill_webcams(GtkWidget *pb){
|
|
#ifdef VIDEO_ENABLED
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"webcams"),linphone_core_get_video_devices(lc),
|
|
linphone_core_get_video_device(lc),CAP_IGNORE);
|
|
#endif
|
|
}
|
|
|
|
void linphone_gtk_fill_video_renderers(GtkWidget *pb){
|
|
#ifdef VIDEO_ENABLED /* video_stream_get_default_video_renderer requires video enabled */
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
MSFactory *factory = linphone_core_get_ms_factory(lc);
|
|
GtkWidget *combo=linphone_gtk_get_widget(pb,"renderers");
|
|
bctbx_list_t *l=ms_factory_lookup_filter_by_interface(factory, MSFilterVideoDisplayInterface);
|
|
bctbx_list_t *elem;
|
|
int i;
|
|
int active=-1;
|
|
const char *current_renderer=linphone_core_get_video_display_filter(lc);
|
|
GtkListStore *store;
|
|
GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
|
|
GtkTreeModel *model=GTK_TREE_MODEL(store=gtk_list_store_new(2,G_TYPE_STRING,G_TYPE_STRING));
|
|
|
|
if (current_renderer==NULL) current_renderer=video_stream_get_default_video_renderer();
|
|
|
|
gtk_combo_box_set_model(GTK_COMBO_BOX(combo),model);
|
|
gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo));
|
|
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),renderer,TRUE);
|
|
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,"text",1,NULL);
|
|
|
|
for(i=0,elem=l;elem!=NULL && i<4 ;elem=elem->next){
|
|
MSFilterDesc *desc=(MSFilterDesc *)elem->data;
|
|
GtkTreeIter iter;
|
|
|
|
/* do not offer the user to select combo 'decoding/rendering' filter */
|
|
if (desc->enc_fmt != NULL || (desc->flags & MS_FILTER_IS_ENABLED) == 0)
|
|
continue;
|
|
|
|
gtk_list_store_append(store,&iter);
|
|
gtk_list_store_set(store,&iter,0,desc->name,1,desc->text,-1);
|
|
if (current_renderer && strcmp(current_renderer,desc->name)==0)
|
|
active=i;
|
|
|
|
i++;
|
|
}
|
|
bctbx_list_free(l);
|
|
if (active!=-1) gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
|
|
#endif
|
|
}
|
|
|
|
void linphone_gtk_fill_video_presets(GtkWidget *pb) {
|
|
GtkComboBox *combo = GTK_COMBO_BOX(linphone_gtk_get_widget(pb, "video_preset"));
|
|
const char *preset = linphone_core_get_video_preset(linphone_gtk_get_core());
|
|
if (preset == NULL) {
|
|
gtk_combo_box_set_active(combo, -1);
|
|
gtk_combo_box_set_active(combo, 0);
|
|
} else {
|
|
gboolean valid;
|
|
GtkTreeIter iter;
|
|
gchar *str_data;
|
|
GtkTreeModel *model = gtk_combo_box_get_model(combo);
|
|
valid = gtk_tree_model_get_iter_first(model, &iter);
|
|
while (valid) {
|
|
gtk_tree_model_get(model, &iter, 0, &str_data, -1);
|
|
if (g_strcmp0(preset, str_data) == 0) {
|
|
gtk_combo_box_set_active_iter(combo, &iter);
|
|
break;
|
|
}
|
|
valid = gtk_tree_model_iter_next(model, &iter);
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
guint timeout_id;
|
|
LCSipTransports tp;
|
|
}PortConfigCtx;
|
|
|
|
static void port_config_free(PortConfigCtx *ctx){
|
|
g_free(ctx);
|
|
}
|
|
|
|
static gboolean apply_transports(PortConfigCtx *ctx){
|
|
GtkWidget *mw=linphone_gtk_get_main_window();
|
|
LCSipTransports tp;
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
linphone_core_get_sip_transports(lc,&tp);
|
|
tp.udp_port=ctx->tp.udp_port;
|
|
tp.tcp_port=ctx->tp.tcp_port;
|
|
linphone_core_set_sip_transports(lc,&tp);
|
|
g_object_set_data(G_OBJECT(mw),"port_config",NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
static PortConfigCtx* get_port_config(void) {
|
|
GtkWidget *mw=linphone_gtk_get_main_window();
|
|
PortConfigCtx *cfg=(PortConfigCtx*)g_object_get_data(G_OBJECT(mw),"port_config");
|
|
if (cfg==NULL){
|
|
cfg=g_new0(PortConfigCtx,1);
|
|
g_object_set_data_full(G_OBJECT(mw),"port_config",cfg,(GDestroyNotify)port_config_free);
|
|
}
|
|
if (cfg->timeout_id!=0) {
|
|
g_source_remove(cfg->timeout_id);
|
|
}
|
|
cfg->timeout_id=g_timeout_add_seconds(2,(GSourceFunc)apply_transports,cfg);
|
|
return cfg;
|
|
}
|
|
|
|
static void transport_changed(GtkWidget *parameters){
|
|
PortConfigCtx *cfg = get_port_config();
|
|
|
|
GtkWidget *udp_random_port=linphone_gtk_get_widget(parameters,"random_udp_port");
|
|
GtkWidget *tcp_random_port=linphone_gtk_get_widget(parameters,"random_tcp_port");
|
|
|
|
GtkWidget *sip_udp_port=linphone_gtk_get_widget(parameters,"sip_udp_port");
|
|
GtkWidget *sip_tcp_port=linphone_gtk_get_widget(parameters,"sip_tcp_port");
|
|
|
|
gboolean udp_is_disabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(parameters,"disabled_udp_port")));
|
|
gboolean tcp_is_disabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(parameters,"disabled_tcp_port")));
|
|
|
|
gboolean udp_is_random=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(udp_random_port));
|
|
gboolean tcp_is_random=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tcp_random_port));
|
|
|
|
int udp_port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sip_udp_port));
|
|
int tcp_port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sip_tcp_port));
|
|
|
|
|
|
gtk_widget_set_sensitive(udp_random_port, !udp_is_disabled);
|
|
gtk_widget_set_sensitive(tcp_random_port, !tcp_is_disabled);
|
|
gtk_widget_set_sensitive(sip_udp_port, !udp_is_disabled && !udp_is_random);
|
|
gtk_widget_set_sensitive(sip_tcp_port, !tcp_is_disabled && !tcp_is_random);
|
|
|
|
cfg->tp.udp_port=udp_is_disabled?0:udp_is_random?-1:udp_port;
|
|
cfg->tp.tcp_port=tcp_is_disabled?0:tcp_is_random?-1:tcp_port;
|
|
}
|
|
|
|
void linphone_gtk_disabled_udp_port_toggle(GtkCheckButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_random_udp_port_toggle(GtkCheckButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_udp_port_value_changed(GtkSpinButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_disabled_tcp_port_toggle(GtkCheckButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_random_tcp_port_toggle(GtkCheckButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_tcp_port_value_changed(GtkSpinButton *button){
|
|
GtkWidget *parameters = gtk_widget_get_toplevel((GtkWidget*)button);
|
|
transport_changed(parameters);
|
|
}
|
|
|
|
void linphone_gtk_show_parameters(void){
|
|
GtkWidget *mw=linphone_gtk_get_main_window();
|
|
GtkWidget *pb=(GtkWidget*)g_object_get_data(G_OBJECT(mw),"parameters");
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
const char *tmp;
|
|
LinphoneAddress *contact;
|
|
LinphoneFirewallPolicy pol;
|
|
GtkWidget *audio_codec_list;
|
|
GtkWidget *video_codec_list;
|
|
int mtu;
|
|
int ui_advanced;
|
|
LCSipTransports tr;
|
|
int min_port = 0, max_port = 0;
|
|
|
|
if (pb==NULL) {
|
|
pb=linphone_gtk_create_window("parameters", linphone_gtk_get_main_window());
|
|
g_object_set_data(G_OBJECT(mw),"parameters",pb);
|
|
}else {
|
|
gtk_widget_show(pb);
|
|
return;
|
|
}
|
|
audio_codec_list=linphone_gtk_get_widget(pb,"audio_codec_list");
|
|
video_codec_list=linphone_gtk_get_widget(pb,"video_codec_list");
|
|
|
|
/* NETWORK CONFIG */
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ipv6_enabled")),
|
|
linphone_core_ipv6_enabled(lc));
|
|
linphone_core_get_sip_transports(lc,&tr);
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"disabled_udp_port")), tr.udp_port==0);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"disabled_tcp_port")), tr.tcp_port==0);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"random_udp_port")), tr.udp_port==-1);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"random_tcp_port")), tr.tcp_port==-1);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"sip_udp_port")), tr.udp_port);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"sip_tcp_port")), tr.tcp_port);
|
|
|
|
linphone_core_get_audio_port_range(lc, &min_port, &max_port);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_min_rtp_port")), min_port);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_max_rtp_port")), max_port);
|
|
if (min_port == max_port) {
|
|
gtk_widget_set_sensitive(GTK_WIDGET(linphone_gtk_get_widget(pb, "audio_max_rtp_port")), FALSE);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_audio_port")), TRUE);
|
|
}
|
|
linphone_core_get_video_port_range(lc, &min_port, &max_port);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_min_rtp_port")), min_port);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_max_rtp_port")), max_port);
|
|
if (min_port == max_port) {
|
|
gtk_widget_set_sensitive(GTK_WIDGET(linphone_gtk_get_widget(pb, "video_max_rtp_port")), FALSE);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_video_port")), TRUE);
|
|
}
|
|
|
|
linphone_gtk_show_media_encryption(pb);
|
|
|
|
tmp=linphone_core_get_nat_address(lc);
|
|
if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"nat_address")),tmp);
|
|
tmp=linphone_core_get_stun_server(lc);
|
|
if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"stun_server")),tmp);
|
|
pol=linphone_core_get_firewall_policy(lc);
|
|
switch(pol){
|
|
case LinphonePolicyNoFirewall:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"no_nat")),TRUE);
|
|
break;
|
|
case LinphonePolicyUseNatAddress:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_nat_address")),TRUE);
|
|
break;
|
|
case LinphonePolicyUseStun:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_stun")),TRUE);
|
|
break;
|
|
case LinphonePolicyUseIce:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_ice")),TRUE);
|
|
break;
|
|
case LinphonePolicyUseUpnp:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_upnp")),TRUE);
|
|
break;
|
|
}
|
|
if(!linphone_core_upnp_available()) {
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb,"use_upnp"));
|
|
}
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb, "use_nat_address"));
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb, "nat_address"));
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb, "nat_address_label"));
|
|
|
|
mtu=linphone_core_get_mtu(lc);
|
|
if (mtu<=0){
|
|
gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),FALSE);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),1500);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),FALSE);
|
|
}else{
|
|
gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),TRUE);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),mtu);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),TRUE);
|
|
}
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"dtmf_sipinfo")),
|
|
linphone_core_get_use_info_for_dtmf(lc));
|
|
/* MUTIMEDIA CONFIG */
|
|
linphone_gtk_fill_soundcards(pb);
|
|
linphone_gtk_fill_webcams(pb);
|
|
linphone_gtk_fill_video_renderers(pb);
|
|
linphone_gtk_fill_video_presets(pb);
|
|
linphone_gtk_fill_video_sizes(linphone_gtk_get_widget(pb,"video_size"));
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"video_framerate")),
|
|
linphone_core_get_preferred_framerate(lc));
|
|
#ifndef VIDEO_ENABLED
|
|
gtk_widget_set_visible(linphone_gtk_get_widget(pb, "camera_preview_button"),FALSE);
|
|
#endif
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"echo_cancelation")),
|
|
linphone_core_echo_cancellation_enabled(lc));
|
|
|
|
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(linphone_gtk_get_widget(pb,"ring_chooser")),
|
|
linphone_core_get_ring(lc));
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"adaptive_rate_control")),
|
|
linphone_core_adaptive_rate_control_enabled(lc));
|
|
/* SIP CONFIG */
|
|
contact=linphone_core_get_primary_contact_parsed(lc);
|
|
if (contact){
|
|
if (linphone_address_get_display_name(contact)) {
|
|
const char *dn=linphone_address_get_display_name(contact);
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")),dn);
|
|
}
|
|
if (linphone_address_get_username(contact))
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")),linphone_address_get_username(contact));
|
|
linphone_address_unref(contact);
|
|
}
|
|
#ifdef BUILD_WIZARD
|
|
gtk_widget_show(linphone_gtk_get_widget(pb,"wizard"));
|
|
#else
|
|
gtk_widget_hide(linphone_gtk_get_widget(pb,"wizard"));
|
|
#endif
|
|
linphone_gtk_show_sip_accounts(pb);
|
|
/* CODECS CONFIG */
|
|
linphone_gtk_init_codec_list(GTK_TREE_VIEW(audio_codec_list));
|
|
linphone_gtk_init_codec_list(GTK_TREE_VIEW(video_codec_list));
|
|
linphone_gtk_draw_codec_list(GTK_TREE_VIEW(audio_codec_list), 0);
|
|
linphone_gtk_draw_codec_list(GTK_TREE_VIEW(video_codec_list), 1);
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"download_bw")),
|
|
linphone_core_get_download_bandwidth(lc));
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"upload_bw")),
|
|
linphone_core_get_upload_bandwidth(lc));
|
|
|
|
/* CALL PARAMS CONFIG */
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "auto_answer_checkbox")), linphone_gtk_auto_answer_enabled());
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "auto_answer_delay_spinbutton")), linphone_gtk_get_ui_config_int("auto_answer_delay", 2000));
|
|
|
|
/* UI CONFIG */
|
|
linphone_gtk_fill_langs(pb);
|
|
ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", 1);
|
|
linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ui_level")),
|
|
ui_advanced);
|
|
linphone_gtk_ui_level_adapt(pb);
|
|
|
|
if (linphone_core_tunnel_available()){
|
|
gtk_widget_set_visible(GTK_WIDGET(linphone_gtk_get_widget(pb,"tunnel_edit_button")), TRUE);
|
|
gtk_widget_set_visible(GTK_WIDGET(linphone_gtk_get_widget(pb,"tunnel_label")), TRUE);
|
|
}
|
|
|
|
/* LDAP CONFIG */
|
|
if( linphone_gtk_is_ldap_supported() ) { // if LDAP provider is available
|
|
linphone_gtk_ldap_display(pb);
|
|
} else {
|
|
// hide the LDAP tab
|
|
GtkNotebook* notebook = GTK_NOTEBOOK(linphone_gtk_get_widget(pb, "notebook1"));
|
|
gtk_notebook_remove_page(notebook,5);
|
|
}
|
|
|
|
gtk_widget_show(pb);
|
|
}
|
|
|
|
|
|
void linphone_gtk_fixed_audio_port_toggle(void) {
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
gboolean fixed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_audio_port")));
|
|
gint min_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_min_rtp_port")));
|
|
gint max_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "audio_max_rtp_port")));
|
|
gtk_widget_set_sensitive(GTK_WIDGET(linphone_gtk_get_widget(pb, "audio_max_rtp_port")), !fixed);
|
|
if (fixed) {
|
|
linphone_core_set_audio_port(linphone_gtk_get_core(), min_port);
|
|
} else {
|
|
linphone_core_set_audio_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
}
|
|
|
|
|
|
void linphone_gtk_fixed_video_port_toggle(void) {
|
|
GtkWidget *mw = linphone_gtk_get_main_window();
|
|
GtkWidget *pb = (GtkWidget *) g_object_get_data(G_OBJECT(mw), "parameters");
|
|
gboolean fixed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb, "fixed_video_port")));
|
|
gint min_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_min_rtp_port")));
|
|
gint max_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb, "video_max_rtp_port")));
|
|
gtk_widget_set_sensitive(GTK_WIDGET(linphone_gtk_get_widget(pb, "video_max_rtp_port")), !fixed);
|
|
if (fixed) {
|
|
linphone_core_set_video_port(linphone_gtk_get_core(), min_port);
|
|
} else {
|
|
linphone_core_set_video_port_range(linphone_gtk_get_core(), min_port, max_port);
|
|
}
|
|
}
|
|
|
|
|
|
void linphone_gtk_edit_tunnel_closed(GtkWidget *button){
|
|
GtkWidget *pb=gtk_widget_get_toplevel(button);
|
|
gtk_widget_destroy(pb);
|
|
}
|
|
|
|
void linphone_gtk_edit_tunnel(GtkButton *button){
|
|
GtkWidget *w=linphone_gtk_create_window("tunnel_config", gtk_widget_get_toplevel(GTK_WIDGET(button)));
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
LinphoneTunnel *tunnel=linphone_core_get_tunnel(lc);
|
|
const bctbx_list_t *configs;
|
|
const char *host = NULL;
|
|
int port=0;
|
|
|
|
if (!tunnel) return;
|
|
|
|
configs = linphone_tunnel_get_servers(tunnel);
|
|
if(configs != NULL) {
|
|
LinphoneTunnelConfig *ltc = (LinphoneTunnelConfig *)configs->data;
|
|
host = linphone_tunnel_config_get_host(ltc);
|
|
port = linphone_tunnel_config_get_port(ltc);
|
|
}
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"host")),host);
|
|
if (port==0) port=443;
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"port")), port);
|
|
|
|
switch(linphone_tunnel_get_mode(tunnel)){
|
|
case LinphoneTunnelModeDisable:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_disable")),1);
|
|
break;
|
|
case LinphoneTunnelModeEnable:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_enable")),1);
|
|
break;
|
|
case LinphoneTunnelModeAuto:
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"tunnel_autodetect")),1);
|
|
break;
|
|
}
|
|
{
|
|
const char *proxy=NULL,*username=NULL,*password=NULL;
|
|
port=0;
|
|
linphone_tunnel_get_http_proxy(tunnel,&proxy,&port,&username,&password);
|
|
if (proxy)
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"http_host")),proxy);
|
|
if (port>0)
|
|
gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"http_port")), port);
|
|
if (username)
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"username")),username);
|
|
if (password)
|
|
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"password")),password);
|
|
}
|
|
|
|
g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_edit_tunnel_closed,w);
|
|
gtk_widget_show(w);
|
|
}
|
|
|
|
void linphone_gtk_tunnel_ok(GtkButton *button){
|
|
GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
LinphoneTunnel *tunnel=linphone_core_get_tunnel(lc);
|
|
LinphoneTunnelConfig *config=linphone_tunnel_config_new();
|
|
|
|
gint port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"port")));
|
|
gboolean enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_enable")));
|
|
gboolean autodetect=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"tunnel_autodetect")));
|
|
const char *host=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"host")));
|
|
const char *http_host=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"http_host")));
|
|
gint http_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"http_port")));
|
|
const char *username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"username")));
|
|
const char *password=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"password")));
|
|
LinphoneTunnelMode mode = LinphoneTunnelModeDisable;
|
|
|
|
if (tunnel==NULL) return;
|
|
if (host && *host=='\0') host=NULL;
|
|
if (http_port==0) http_port=8080;
|
|
linphone_tunnel_clean_servers(tunnel);
|
|
linphone_tunnel_config_set_host(config, host);
|
|
linphone_tunnel_config_set_port(config, port);
|
|
linphone_tunnel_add_server(tunnel, config);
|
|
|
|
if (enabled){
|
|
mode = LinphoneTunnelModeEnable;
|
|
}else if (autodetect){
|
|
mode = LinphoneTunnelModeAuto;
|
|
}
|
|
linphone_tunnel_set_mode(tunnel, mode);
|
|
linphone_tunnel_set_http_proxy(tunnel,http_host,http_port,username,password);
|
|
|
|
gtk_widget_destroy(w);
|
|
}
|
|
|
|
|
|
void linphone_gtk_tunnel_cancel(GtkButton *button){
|
|
|
|
}
|
|
|
|
static void show_dscp(GtkWidget *entry, int val){
|
|
char tmp[20];
|
|
snprintf(tmp,sizeof(tmp),"0x%x",val);
|
|
gtk_entry_set_text(GTK_ENTRY(entry),tmp);
|
|
|
|
}
|
|
|
|
static int read_dscp(GtkWidget *entry){
|
|
const char *val=gtk_entry_get_text(GTK_ENTRY(entry));
|
|
const char *begin;
|
|
int ret=0;
|
|
if (val==NULL || val[0]=='\0') return 0;
|
|
/*skip potential 0x*/
|
|
begin=strstr(val,"0x");
|
|
if (begin) begin+=2;
|
|
else begin=val;
|
|
if (sscanf(begin,"%x",&ret)==1)
|
|
return ret;
|
|
return -1;
|
|
}
|
|
|
|
void linphone_gtk_dscp_edit(void){
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
GtkWidget *widget=linphone_gtk_create_window("dscp_settings", linphone_gtk_get_main_window());
|
|
show_dscp(linphone_gtk_get_widget(widget,"sip_dscp"),
|
|
linphone_core_get_sip_dscp(lc));
|
|
show_dscp(linphone_gtk_get_widget(widget,"audio_dscp"),
|
|
linphone_core_get_audio_dscp(lc));
|
|
show_dscp(linphone_gtk_get_widget(widget,"video_dscp"),
|
|
linphone_core_get_video_dscp(lc));
|
|
gtk_widget_show(widget);
|
|
}
|
|
|
|
void linphone_gtk_dscp_edit_response(GtkWidget *dialog, guint response_id){
|
|
LinphoneCore *lc=linphone_gtk_get_core();
|
|
switch(response_id){
|
|
case GTK_RESPONSE_OK:
|
|
linphone_core_set_sip_dscp(lc,
|
|
read_dscp(linphone_gtk_get_widget(dialog,"sip_dscp")));
|
|
linphone_core_set_audio_dscp(lc,
|
|
read_dscp(linphone_gtk_get_widget(dialog,"audio_dscp")));
|
|
linphone_core_set_video_dscp(lc,
|
|
read_dscp(linphone_gtk_get_widget(dialog,"video_dscp")));
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
gtk_widget_destroy(dialog);
|
|
}
|
|
|
|
void linphone_gtk_enable_auto_answer(GtkToggleButton *checkbox, gpointer user_data) {
|
|
gboolean auto_answer_enabled = gtk_toggle_button_get_active(checkbox);
|
|
linphone_gtk_set_ui_config_int("auto_answer", auto_answer_enabled ? 1 : 0);
|
|
}
|
|
|
|
gboolean linphone_gtk_auto_answer_enabled(void) {
|
|
return (gboolean)linphone_gtk_get_ui_config_int("auto_answer", 0);
|
|
}
|
|
|
|
void linphone_gtk_auto_answer_delay_changed(GtkSpinButton *spinbutton, gpointer user_data) {
|
|
int delay = (int)gtk_spin_button_get_value(spinbutton);
|
|
linphone_gtk_set_ui_config_int("auto_answer_delay", delay);
|
|
}
|
|
|
|
void linphone_gtk_notebook_current_page_changed (GtkNotebook *notebook, GtkWidget *page, guint page_num, gpointer user_data) {
|
|
#ifndef HAVE_LIBUDEV_H
|
|
if (page_num == 1) {
|
|
// Multimedia settings - we reload audio and video devices to detect
|
|
// hot-plugged devices
|
|
g_message("Opened multimedia page... reloading audio and video devices!");
|
|
linphone_gtk_reload_sound_devices();
|
|
linphone_gtk_reload_video_devices();
|
|
}
|
|
#endif
|
|
}
|